HNHacker News
TopNewBestAskShowJobs

PuercoPop

1,153 karma · joined April 1, 2012

submissionscomments
PuercoPop··on Please don't use Slack for FOSS projects
> Open source is a form of software licensing that lots of people develop and use for lots of different reasons. That's it.

Open is more than one form of software licensing, each license modified by the different idiosyncrasies and values of different people that develop software.

> Everything else is politics and philosophy

Open source IS politics as well. The origin of the term itself is a way to subvert Free Software

PuercoPop··on Please don't use Slack for FOSS projects
znc comes with an web GUI to admin/configure it.
PuercoPop··on Please don't use Slack for FOSS projects
> Would it also be bad to host the project's source code on GitHub.

Some Free Software people certainly think that. It is imho at least problematic. For example, the unicorn web server developer, finds github problematic from the 'UX' side in addition to dependence on proprietary software and infrastructure (which creeps into the commit messages).

"Contributing to unicorn is socially as easy as contributing to git or the Linux kernel. There is no need to signup for anything, no need to ever touch a bloated web browser."[0]

[0]:http://bogomips.org/unicorn-public/20140801213202.GA2729%40d...

PuercoPop··on CL21 – Common Lisp in the 21st Century
The reason there are adding the cl-prefix in cl-lib is that previously cl.el replaced elisp functions with the cl equivalent ones.

lispm already covered that cl: is packages, not a prefix but I'd like to add one of the reasons elisp doesn't have any similar of namespaces is due RMS thiking "prefixes are better"[0]

[0]: https://lists.gnu.org/archive/html/emacs-devel/2013-07/msg00...

PuercoPop··on A difference between Haskell and Common Lisp
Minor nitpick. The loop at the end could make the range by 'for i from 1 upto 4' instead of a list literal to more similar to the haskell code.
PuercoPop··on Compiling to WebAssembly: It’s Happening
> "walled gardens" that were Lisp machines back in the day, that force you to write code in Lisp,

Lisp machines come with Fortran and C compilers.

PuercoPop··on Django Awarded MOSS Grant from Mozilla
Yes, the problem of _empathy_.

Also as pointed above, the issue is not a word _offends you_

PuercoPop··on Show HN: Parinfer – a simpler way to write Lisp
> Still expressed as lists when it comes to the syntax level.

alists are not expressed as lists.

PuercoPop··on Embeddable Common-Lisp Android 0.0.1 released
Great work from the new ECL maintainer, jackdaniel!
PuercoPop··on A conversation with Sussman on AI and asynchronous programming
It seems more inline with Justification based/Truth maintenance systems than hard AI.
PuercoPop··on Clojure: If Lisp is so great, why do we keep needing new variants?
FYI: STM is available for Common Lisp, including in the JVM

https://github.com/cosmos72/stmx

PuercoPop··on One Major Difference Between Clojure and Common Lisp
> tail call optimisation is not possible in any language.

Afaik it is possible in racket. Read the note at the end here: http://matt.might.net/articles/lexers-in-racket/

PuercoPop··on One Major Difference Between Clojure and Common Lisp
You are right, should have said recursion instead.
PuercoPop··on One Major Difference Between Clojure and Common Lisp
His build implementation uses tail recursion which is not preferred in CL. One can build in a similar way that as shown at the end.

    (defun build (list-1 list-2)
      (loop
       :for elem-1 :in list-1
       :for elem-2 :in list-2
       :collect (list elem-1 elem-2)))

A much bigger difference imho between Clojure and Common Lisp is that the former is built on abstractions, conj, while the latter is built on concrete cons cells. There are more other significant differences but I don't want to flame/argue.
PuercoPop··on Practical Emacs Lisp
As far as dash.el goes, I find lispm's critique of dash.el pretty convincing[0]. However a more profilic emacs coder fried of mine is undeterred and keeps using modern emacs lisp. I think much of the community does as well.

[0]: https://www.reddit.com/r/lisp/comments/29ufoc/it_is_not_hard...

About Scheme's regexp SRFI, have you seen rx.el? Not quite but I like it myself.

PuercoPop··on Practical Emacs Lisp
First I forgot to add I Xah Lee's ergo emacs was a valuable resource when learning Emacs. AFAIR it succintly explained emacs base abstractions.

On the setq, I what I meant was iterating through setqs and while (and I seem to recall even catch/throw) as agumonkey mentioned.

Then again, 'in my mind', idiomatic elisp uses cl-lib :D. so (cl-incf total-count) would be better. snakeCase is unidiomatic as well.

PuercoPop··on Practical Emacs Lisp
I perused a couple of links. This code [0] is pretty much unidiomatic. Closing parens one per line and using setq all over the place.

[0]: http://ergoemacs.org/emacs/elisp_grep_string_inside_tag.html

PuercoPop··on Picoc: A very small C interpreter for scripting
In similar spirit: https://docs.enlightenment.org/auto/eio/embryo_main.html

Enlightment uses its own Scripting Languagew throught the EFL.

PuercoPop··on Scheme vs. Python (2011)
So C has closures now?

    #include <stdio.h>
    
    int x = 1;
    
    int f(int y) {
      return x + y;
    }
    
    int
    main(argv, argc) {
      printf("f(2): %i\n", f(2));
    }
The reason they are called closures is because they close over the, lexical, environment where the function was defined.

Python doesn't have lexical scope, hence it doesn't have closures.

PuercoPop··on Scheme vs. Python (2011)
Python is so ideological it is not even funny. It has a crippled lambda because Guido couldn't find a syntax he liked for it. It doesn't have tail call elimination because Guido is under the, mistaken, impression that they inhibit backtraces. The zen of python spouts explicit is better than implicit as a marketing slogan to cover up a design wart with Python's lolscope. It only had local and global scope. Python Scope is still broken[0] btw. But don't worry, it is not a bug because it is documented. (╯°□°)╯︵ ┻━┻. The only reason Python passes as a language with good design is because people compare it to PHP or Javascript.

How is the numerical tower impractical? Having to check for overflow/underflow after every addition is what is impractical in my book.

> I am big fan of ... Common Lisp ... There is so much beauty and elegance.

Idk where to people get the idea that Common lisp is 'beatiful and elegant' (in opposition to practical I may add). It is eminently practical. Have you seen loop and format (which btw Python has adopted with some glaring _practical_ omissions like list iteration ~{~}.)? The whole anything but nil is true to allow functions like digit-char-p to return a number instead of t is another practical design choice. Do you think there is anything elegant in modifying the readtable? I could go on and on. CL is a practical language that, apparently due to ESR's nirvana bullshit quote, people who haven't used it have a misconception about its design.

But back to the point, Scheme's design (ideology if you want) is to play to pick features that synergize as to allow discard others as they can be expressed with the previous features/concepts. You don't need iteration, as it is a special case of recursion. You need iterators, you have map, which is just a function the user can define, etc. And this is relevant to teaching computation as it allows the teacher to waste as little time teaching a language and allows him to focus on CONCEPTS. The amount of scheme knowledge needed to finish the SICP can be taught in 15 minutes (It doesn't use macros). All the difficulty lies in the concepts it deals with. Getting the language out of the way allows to cover a lot of ground, for example in the SICP one implements a Virtual Machines and a compilers targeting it.

Now if you want to argue that nowadays the student needs to learn how to pipe software together and has less need for concepts that is another thing altogether[2], but saying that Python is practical (as opposed to ideological) and Scheme's 'ideological' choices hampers the students learning is bullshit.

[0]: https://bugs.python.org/issue24321#msg244357

[1]: https://twitter.com/whitequark/status/604088954816716800

[2]: Of which I'd quote Dijkstra: "It is the university responsibility to give society not what it wants but what it needs."

PuercoPop··on Scheme vs. Python (2011)
> You can program functionally in Python.

Python doesn't even have closures.

> Interpreted

Languages are neither interpreted nor compiled. Implementations are.

PuercoPop··on Ceramic – Turn Lisp web applications into desktop apps
as JayVanguard already pointed out native means another thing. but putting that aside.

You are confusing what HTML and XML are if you think they are similar. XML is a way to encode data, validate it conforms to a schema, query it, etc. HTML is more than the surface syntax. It includes an schema and semantics (the DOM, the CSS OM, the boxing model, etc). Using XML as a declarative layer on top of their UI, as android does, does not make it similar to writing HTML because of the completely different semantics associated with it.

Android takes all the xml layouts and compile them and expose them through the R(esource) class.

PuercoPop··on Ceramic – Turn Lisp web applications into desktop apps
It is a good option, but not on topic of CL GUI libraries.
PuercoPop··on Using Emacs and Git with Magit 2.1
it is also harder from the CLI to stage granular changes (git add -p helps to a point).
PuercoPop··on Using Emacs and Git with Magit 2.1
So you didn't read the manual or at least the help for the command you were about to use and blame magit for not doing what you expected?

As with many emacs commands you use C-u if you want to specify the refspec to push to.

PuercoPop··on Ruby Is Defined by Terrible Tools
You are replying as if had I addressed your other statement. I pointed out that the general tooling woes is not due to its dynamic typing by providing a counter example.

As for your other statement I also disagree:

> I'm not arguing that it's better than having good tooling -- just that the lack of tooling adds some interesting constraints that, in some ways, force us to write simpler code.

What lack of tooling (and introspection in general) deprive us from is from forming a clear picture of what is going on, perspective. To illustrate my point I'll quote a Ken Pitman's annecdote:

> Last night on my Lisp Machine I was frustrated by the absence of NT file support. I had no idea how file support was implemented, but I had a general working understanding of how the Lisp Machine was organized, and within a small number of hours I had learned about how to extend the operating system to talk to NT over TCP and implemented a new set of classes so that I could transparently talk to my NT box over my local ethernet. A lot of my ability to do this was enabled by the ability to point and click on objects in order to debug them and inspect them without any fear or confusion about whether I was using the right sources, the right packages, etc.

https://groups.google.com/forum/#!topic/comp.lang.lisp/XpvUw...

However I think this is a more nuanced point, therefore I have no interest in arguing it over the internet. I see the case for constraints resulting in simpler code.

What I objected to is using Ruby's dynamic typing as a cop-out and try to pass it as trade-off.

PuercoPop··on Ruby Is Defined by Terrible Tools
Give Pharo a try, I think you'd be pleasantly surprised.
PuercoPop··on Ruby Is Defined by Terrible Tools
> This is definitely the downside of ruby's dynamic/duck typing.

No, IDEs were pioneered (and if you checkout Pharo you'll see they are still pushing the boundaries) by dynamic languages that allow runtime refleciton. Like smalltalk.

PuercoPop··on Thomas Piketty: “Germany has never repaid.”
There are ways. See the case of Argentina.
PuercoPop··on John Carmack working on Scheme as a VR scripting language
Lisp macros are powerful, so the core of the language can be kept simple. However, many languages take an alternate approach and codify the most common programming patterns into their specification. The result is a compromise that works for the majority of cases, and better understood than custom macros.

The semantic core is kept simple. That doesn't mean lisps don't provide constructs for common patterns. Ej. Loop, with-open-file or defclass or Racket's for/ constructs.

Plus a good written macro is easy to understand and I'd argue most of macros are good written. In fact I'd like to see a macro that what it does is unclear on a widely use liso library.

> - Compilers can optimize well known constructs better than equivalent macros in lisp.

Lookup compiler macros. Macros can help the compiler optimize the code.

← PreviousPage 6 of 12Next →