HNHacker News
TopNewBestAskShowJobs

horrido

275 karma · joined October 5, 2014

submissionscomments
horrido··on JavaScript has beguiled the current generation of software developers
> It teaches a way of thinking, and it really doesn't matter much which language is used as long as the basic principles are covered.

Nevertheless, schools do not want to teach an inferior language that encourages bad programming habits. They (now) tend to rely on languages with a vocational bent, such as Python and Java. I remember my days in university when odd languages like Scheme and Turing were taught. Now, it's sensible to at least try to prepare the student for the job market. I'm glad they didn't stoop to JavaScript.

> If you are a new programmer reading the article and feeling discouraged, don't lose heart. Build stuff and you'll learn.

Why should a new programmer feel discouraged? There are plenty of good languages to choose from (Java, C#, Python, C++, Ruby, etc.). They offer varying levels of ease, but Python and Ruby would be more than good enough. If you want to do web development, use a transpiled language (). That'll save you much of the grief of JavaScript. (My personal favourite is Amber Smalltalk.)

I agree, build stuff and learn.

horrido··on JavaScript has beguiled the current generation of software developers
So who's making arguments without supporting facts? The Hacker Life provides evidence that startups prefer Ruby, C and Python. Fortune 500 companies may use JS for client-facing web UI applications (which are generally not mission-critical), but for heavy-duty shit, they'll stick to Java, C#, Python, C++, etc. Show me what Fortune 500 companies are replacing these tried-and-true workhorses with JavaScript.

As for games, what serious gaming platform relies on WebGL? Most games are written in C++ for a reason: maximum performance. When I was Project Team Leader of the Windows NT Driver Group at ATI Technologies (now AMD), all the OpenGL software I saw was written in C++. JavaScript could never have been usable, even with V8.

Smalltalk, seriously. It's still used today around the world by many businesses. Cincom and GemTalk are major Smalltalk vendors. I have friends working at Cherniak Software and Simberon, both important Smalltalk software houses. ESUG (European Smalltalk User Group) is a mammoth organization representing hundreds of companies using Smalltalk. What did you say about "a position of obvious ignorance?"

horrido··on JavaScript has beguiled the current generation of software developers
Clearly, Node is widely used. It would be silly to deny that. The real question is to what extent is it being used, i.e., is it used to write large, mission-critical systems, is it used beyond developing client-facing web applications (which tend not to be very big), is it used company-wide in lieu of previous language infrastructures such as Java, C#, Python and C++? Now, that would be impressive.
horrido··on JavaScript has beguiled the current generation of software developers
Many enterprises are, indeed, using SPA and Node...for the client-facing, non-mission-critical web UI software. These applications tend not to be very large, and on this scale, these tools are usable. But once you get to the really heavy stuff that enterprises rest their critical core business on, they'll stick with real languages like Java, C#, Python, C++ and Scala...things that they trust without question.
horrido··on JavaScript has beguiled the current generation of software developers
It was hyperbole. Of course, most of these frameworks are still around, but their popularity waxes and wanes with each new kid on the block (React is the latest).
horrido··on JavaScript has beguiled the current generation of software developers
But why did the ecosystem get out of hand so easily? Because the sloppiness of the language encouraged it or made it easy to abuse it. JavaScript's ecosystem is notoriously bad in this respect (cf. with Java or Python or Ruby).
horrido··on You Don't Have to Use JavaScript
As you pointed out yourself, JavaScript is a poorly designed mess. It may be a "high level" language, but it's also dangerous to use. None of the linters do a perfect job of ferreting out all the problems. In other words, JavaScript will never be 100 per cent "safe" to use. Treating it as a lower level of abstraction doesn't harm us. It simply gives us a foundation for using better languages, and that has to be a Good Thing.
horrido··on You Don't Have to Use JavaScript
That's like saying if you compile C++ to Intel x86 assembler, you're still programming in assembler. JavaScript is the "assembly language" of the web; compiling (transpiling) to it is not directly programming in it.

Now, you're half-right in that you may occasionally need to drop into JavaScript to do some "low level" things. This is no different from C++, where you may occasionally need to drop into x86 assembler to do some low level things, such as local speed optimization, or hitting memory-mapped registers.

In both cases, you're programming at a higher level using safer and more sophisticated abstractions.

horrido··on You Don't Have to Use JavaScript
MoD411 is referring to "loose typing and freewheeling coercions." This is not about "type safety." It's about having a predictable and reasonable binding of types. JavaScript is very sloppy in this respect, especially with regards to the underlying semantics.
horrido··on You Don't Have to Use JavaScript
The article gives 8 examples of transpiled languages, 4 dynamically typed and 4 statically typed. There's no real preference for static typing, and in fact I'm a big fan of dynamic typing.

However, there's a difference between a strongly typed dynamic language and a weakly typed dynamic language. JavaScript is an example of the latter and it's done very badly (eg, inconsistent semantics). The lack of discipline makes it difficult to write safe, reliable software. Thus, JavaScript is ill-suited for serious software engineering.

horrido··on How can JavaScript be stopped from spreading like a cancer?
My mother died from breast cancer, so yes, cancer is fucking scary. So is JavaScript, which is metastasizing into nearly every other application domain in IT, including the mobile space, the server side, the Internet of Things, video gaming, etc. I've made it my personal mission to evangelize against this language. (Previously, I was a Smalltalk evangelist.)
horrido··on How can JavaScript be stopped from spreading like a cancer?
Not insightful? I'm the author. I drew attention to several important facts about JavaScript...

1) The language has terribly inconsistent semantics, esp. with regards to its loose typing and aggressive coercions.

2) Just because JavaScript is the native language of the web browser, it does not necessarily mean that you must program in it directly. There are dozens of better languages that transpile to it.

3) Despite Node's popularity, JavaScript is ill-suited for the server side. Have you heard the axiom, "Use the best tool for the job"? On the server side, JS is definitely not the best tool. There are much better languages, such as Go or C# or Scala, just to name a few.

4) ECMA is turning JavaScript into a very complicated language. Just look at the size of ES6's language spec! JS can no longer claim to be an "easy to learn" language, which was one of the key reasons for its growing popularity.

berserker-one was correct: I wrote a satirical article. It was meant to be funny, and I can testify that many people do find it amusing (based on the responses I've been getting). I'm sorry you don't share my sense of humour. You need to lighten up.

horrido··on An Open Letter to ECMA
Before everybody jumps the gun, this article is a piece of satire. It's meant to be funny. It's meant to entertain you, as well as inform you. Please take it in the spirit in which it was written. Enjoy.
horrido··on The Top Things Wrong with JavaScript
9) Not a problem, per se, but it's the expectation that JS is a great language. This erroneous belief is misleading and dangerous, drawing in people who don't know any better.

10) As I said, while you can't get JS out of the web browsers, you can transpile to it as an assembly language. That was my main point.

horrido··on The Argument Against Climate Change
Hmmm, apparently my attempt at sarcasm is going over the heads of my readers. Whoosh!

Perhaps I need to be less subtle...

horrido··on Demystifying Bodhi Meditation
Actually, it doesn't matter. Visualization is hard work. Meditation is hard work. It's all the same.
horrido··on Why Aren't People Using Smalltalk?
Exactly right! Smalltalk never recovered because of its PR problem. Smalltalk has been free (or inexpensive) for over 15 years now.
horrido··on Why Aren't People Using Smalltalk?
Exactly! As mentioned in the article, Alan Kay's vision of OOP was corrupted into the rubbish we see today in C++, Java, Scala, etc. Today's conventional OOP is nothing more than an extension to Abstract Data Types...useful, but not nearly as powerful as Smalltalk's "true" OOP (https://medium.com/@richardeng/getting-the-message-667d77ff7...).
horrido··on What are the biggest reasons for not using Smalltalk?
Yes, it's true. Most Smalltalk dialects use a special IDE. This is because the biggest advantage of using Smalltalk for development is the "live" programming environment where you can examine any object in the executing program (thanks to Smalltalk's astonishing reflection capabilities) and you can alter the running code and watch the results in real time. This is not possible with conventional, file-based tools such as Emacs or Eclipse.

Smalltalk development is a fundamentally different paradigm from the conventional, file-based development process. It does require you to adapt to a new way of doing things, but this confers fantastic benefits. The combination of super-simple and elegant syntax with a powerful IDE makes developers much more productive than programming in Java or C++ [1]. Having a simple syntax minimizes the cognitive load on the programmer, making it very easy to master the programming tool. When you master your tools, you work at maximum efficiency and effectiveness.

However, if you really must use your file-based tools, there is a command-line Smalltalk called Gnu Smalltalk. IMO, however, giving up on live programming is too great a sacrifice just for this obsession with file-based editors and tools.

[1] https://smalltalkrenaissance.wordpress.com/2015/02/16/smallt...

horrido··on The Smalltalk Revolution
BTW, functional programming does not impress me at all...

"Programming with the Object Oriented paradigm is creating a program by identifying and modeling the Problem Domain Entities as objects, and then make them collaborate between themselves to solve each problem instance. Programming with the Functional paradigm is modeling the problem as a mathematical problem, and creating a mathematical function (by composing other functions) that for each problem instance, computes the problem solution." (From http://goo.gl/K4U0Nh)

It is unnatural for humans to model the world in a functional way. The world consists of objects, not functions. That's why I've never liked FP.

horrido··on The Smalltalk Revolution
Be prepared to be surprised. Yes, historically Smalltalk has evolved rather slowly. However, with the Pharo project, Smalltalk is enjoying a resurgence because the project is working vigorously to evolve Smalltalk to the next level. Check back in another year or so and see some major improvements. That's why I say, this is not your father's Smalltalk.
horrido··on The Smalltalk Revolution
"It may be because I actually do know better."

And what is it that you know better? It would be difficult to defend current software development practice as being ideal or supremely productive. However, I can see other non-technical reasons for sticking with what you know. For example, your business organization may not be willing to overhaul its IT operations in order to support Smalltalk. There would be financial costs. There would be hiring issues (from what talent pool would you draw from?). There would be lack of managerial experience in running a Smalltalk project. There would be interoperability issues with existing applications. And so on.

But from the purely technical standpoint, you have to know that the way things are cannot be ideal. There will always be easier and more productive ways to write software. The trick is to find out what those ways are.

horrido··on The Smalltalk Revolution
I don't think that's what the article is saying at all. It says that when you've done things the same way for most or all of your professional life, as I have (30 years programming in FORTRAN, C/C++/C#/Objective-C, Java, Python using text editors, textual compilers, command line tools of all sorts, Eclipse, Visual Studio), you become so used to it, you become so good and efficient at it, that it seems like the only or best way to develop software. You find yourself in a comfort zone. This was my experience; I was your typical code jockey.

However, even after 30 years, I still had a tiny feeling inside of me that there was a better way to do things, one that was easier on my brain. All I had to do was "let go." Let go of my preconceptions. Open my mind to other possibilities. Recognize that my past experience was based on crude methods from decades ago (circa 1980) that have been optimized and refined to their current stratospheric levels.

When I first tried Smalltalk, it took a little while to change my mindset and adapt. Now, I see why it is such a super-productive tool. It directly aids the natural, cognitive flow of developing an application concept. There is less stress on my brain (whether I'm aware of that stress or not – most people are not). The result is that I can write an application in a fraction of the time that it would've taken me in Java or C#. And it's more fun, to boot!

If we could pit the world's best Java programmer against the world's best Smalltalk programmer in a cage match to see who finishes a moderate-size application first, I know who I'd bet on. I wasn't exaggerating when I said "a fraction of the time."

You have no idea how refreshing it is to only keep a minimalist language in your head. Thanks to the simplicity and elegance of the syntax, code is easier to write than in Java, and much, much easier to read. It takes more cognitive effort to read C++ or Java or Haskell or Clojure. How can anyone take issue with this??

People are always saying how much more expressive this language is over that one because of some much-touted language feature(s). Aside from anecdotal tales, I've never seen scientific evidence that language features overall have a great impact on how algorithms are implemented. Sure, some languages are exceptional in narrow problem domains, but for general-purpose programming across multiple domains, I've never seen much difference among the dozen languages I've used. Certainly, Smalltalk is not constrained in this respect for most use cases.

So, no, you're not ignorant. You just haven't tried to break out of your comfort zone for whatever personal reasons you may have. If the suggestion that you're human offends you, then you need to dial back your sensitivity because all I'm doing is calling it as I see it.

Denial is not a river in Africa.

horrido··on Learning Curves for Different Programming Languages
No, it's not. Software developers are human. Being a professional does not always override human nature. Statistically, most "professional" software developers will not want to adopt a language with a high cognitive load.
horrido··on Learning Curves for Different Programming Languages
Re: Haskell monads

If something hurts my brain, I don't want to do it; I don't care about the long-term benefits. Most humans feel the same way and that's why Haskell will never become mainstream.

horrido··on Where Smalltalk Went Wrong (2004)
Also, people bitch about not being able to use their favourite editors. I've never understood this, either. In my 20+ years in IT, I've never been wedded to any particular editor. And the way source is organized and presented in the Smalltalk environment (via the class browser), I've never needed the power of emacs or Eclipse or Sublime Text. Super-editors are for file-based software development. In Smalltalk, they're rather unnecessary.
horrido··on Where Smalltalk Went Wrong (2004)
I find this resistance to the Smalltalk environment a bit puzzling. It's really fundamentally no different from modern IDEs and virtual machine runtimes such as JVM. The key differentiator is the fact that every object in the Smalltalk environment is "live" and can be examined and altered at will. One of the great benefits from this fallout is the powerful debugger.

Rather than whining about how Smalltalk doesn't play well with existing file-based tooling, we should focus on improving and extending the tooling for the Smalltalk environment. We have an opportunity here to define the future. Smalltalk is a break from the traditional way of doing things (the use of files and folders is positively antediluvian!). It's truly innovative.

The transition may incur some cost and pain now, but positive change is never free. If you argue we should wait for a more opportune time, the question is, "If not now, then when?" What exactly are we waiting for?

If you argue we should never change, files and folders are perfect forever and ever, then I say we are stuck in a rut. Software engineering is off the rails.

horrido··on Where Smalltalk Went Wrong (2004)
This is exactly right. People are so invested in what they've learned that they are reluctant to give it up and try something new and different. Humans are creatures of habit.

For some reason, this has never afflicted me. I've used many languages and environments in my time (eg, FORTRAN, Tandem TAL, C/C++/C#/Objective-C, Java, Python, Go, and Smalltalk), and I've treated each and every one of them as a fun opportunity to play and learn. This is my intellectual playground and those languages are my toys! Smalltalk was completely different from everything else I had used over 20+ years, and it still didn't phase me. Go figure.

Today, I continue to have a warm place in my heart for Smalltalk.

horrido··on Where Smalltalk Went Wrong (2004)
Pharo is the closest thing to a de facto standard. It has a huge following, perhaps even the biggest of all Smalltalk users. It's the reference implementation for Seaside, the best of the Smalltalk web frameworks. It's the reference implementation for Amber, the best of the client-side web tools. I see little reason to consider anything else.
horrido··on Where Smalltalk Went Wrong (2004)
Unless you always stick to languages with the same familiar "look", learning a new language will always need more time to acclimate to. I've used FORTRAN, Tandem TAL, C/C++/C#/Objective-C, Java, Python, Go, and Smalltalk. No real problems with picking any of these up, but I always struggle with Lisp.

Language design is often a balance between making something terse and something human readable. Smalltalk strikes the perfect balance, AFAIC. Having English-like method names and variables is really quite nice. And Smalltalk still manages to be a lot less verbose than every other language I've ever used.

← PreviousPage 2 of 3Next →