- Jan 2023
-
news.ycombinator.com news.ycombinator.com
-
They are foldable in IDEs
Everything is foldable in IDEs so long as the IDEs make them foldable.
-
-
www.colbyrussell.com www.colbyrussell.com
-
Considerations
What about chained dotted access?
foo.bar.baz
is probably okay asbar.baz @ (the Foo)
(or even@the Foo
), but probably not if it takes the formbar.baz from the Foo
. (It just doesn't look reasonable to me.)Alternatively, what about
@bar.baz for the Foo
?
-
-
buttondown.email buttondown.email
-
In Lua you can write raw, multiline strings with [[]]: [[ Alice said "Bob said 'hi'". ]]
This is indeed very good (for the reasons stated here).
-
-
docdrop.org docdrop.org
-
how important is the concrete syntax of their language in contrast to
how important is the concrete syntax of their language in contrast to the abstract concepts behind them what I mean they say can someone somewhat awkward concrete syntax be an obstacle when it comes to the acceptance
-
- Nov 2022
-
www.moserware.com www.moserware.com
-
there is no single perfect universal programming language. Until I came to that point, I wasted a lot of time thinking that GW-BASIC QBASIC QB 4.5 VB4 Delphi Java C++ C# 1.0 was the only language I would ever need
-
- Sep 2022
-
news.ycombinator.com news.ycombinator.com
-
The LISP part, though, is not going well. Porting clever 1970s Stanford AI Lab macros written on the original SAIL machine to modern Common LISP is hard. Anybody with a knowledge of MACLISP want to help?
-
-
stallman.org stallman.org
-
I find C++ quite ugly
-
- Aug 2022
-
-
Obnoxious.
As someone recently pointed out on HN, it's very common nowadays to encounter the no-one-knows-else-what-they're-doing-here refrain as cover—I don't have to feel insecure about not understanding this because not only am I not alone, nobody else understands it either.
Secondly, if your code is hard to understand regarding its use of
this
, then your code his hard to understand.this
isn't super easy, but it's also not hard. Your code (or the code you're being made to wade into) probably just sucks. Thethis
confusion is making you confront it, though, instead of letting it otherwise fly under the radar.* So fix it and stop going in for the low-effort,this
-centric clapter.* Not claiming here that
this
is unique; there are allowed to be other things that work as the same sort of indicator.
-
-
www.cs.virginia.edu www.cs.virginia.edu
-
There are no static variables and no initialization
This is an excellent property. It's not a weakness.
-
- Jun 2022
-
tinyclouds.org tinyclouds.org
-
The fundamental mistake of Node.js was diverging from the browser
-
- May 2022
-
news.ycombinator.com news.ycombinator.com
-
an acknowledgement of network effects: LP is unlikely to ever catch on enough to be the majority, so there needs to be a way for a random programmer using their preferred IDE/editor to edit a "literate" program
This is part of the reason why I advocate for language skins for comparatively esoteric languages like Ada.
-
-
log.schemescape.com log.schemescape.com
-
memory usage and (lack of) parallelism are concerns
Memory usage is a concern? wat
It's a problem, sure, if you're programming the way NPMers do. So don't do that.
This is a huge problem I've noticed when it comes to people programming in JS—even, bizarrely, people coming from other languages like Java or C# and where you'd expect them to at least try to continue to do things in JS just like they're comfortable doing in their own language. Just because it's there (i.e. possible in the language, e.g. dynamic language features) doesn't mean you have to use it...
(Relevant: How (and why) developers use the dynamic features of programming languages https://users.dcc.uchile.cl/~rrobbes/p/EMSE-features.pdf)
The really annoying thing is that the NPM style isn't even idiomatic for the language! So much of what the NodeJS camp does is so clearly done in frustration and the byproduct of a desire to work against the language. Case in point: the absolutely nonsensical attitude about always using triple equals (as if to ward off some evil spirits) and the undeniable contempt that so many have for
this
.
-
-
www.mindprod.com www.mindprod.comSCID1
-
local a (e.g. aPoint) param p (e.g. pPoint) member instance m (e.g. mPoint) static s (e.g. sPoint)
This is really only a problem in languages that make the unfortunate mistake of allowing references to unqualified names that get fixed up as if the programmer had written
this.mPoint
orFoo.point
. Even if you're writing in a language where that's possible, just don't write code like that! Just because you can doesn't mean you have to.The only real exception is distinguishing locals from parameters. Keep your procedures short and it's less of a problem.
-
-
doc.cat-v.org doc.cat-v.org
-
This can get much worse than the above example; the number of \’s required is exponential in the nesting depth. Rc fixes this by making the backquote a unary operator whose argument is a command, like this: size=‘{wc -l ‘{ls -t|sed 1q}}
-
- Mar 2022
-
akkartik.name akkartik.name
-
Understanding a strange codebase is hard.
John Nagle is fond of making the observation that there are three fundamental and recurring questions that dominate one's concerns when programming in C.
More broadly (speaking of software development generally), one of the two big frustrations I have when dealing with a foreign codebase is the simple question, "Where the hell does this type/function come from?" (esp. in C and, unfortunately, in Go, too, since the team didn't take the opportunity to fix it there when they could have...). There's something to be said for Intellisense-like smarts in IDEs, but I think the criticism of IDEs is justified. I shouldn't need an IDE just to be able to make sense of what I'm reading.
The other big frustration I often have is "Where does the program really start?" Gilad Bracha seems to really get this, from what I've understood of his descriptions about how module definitions work in Newspeak. Even though it's reviled, I think Java was really shrewd about its decisions here (and on the previous problem, too, for that matter—don't know exactly where FooBar comes from? welp, at least you can be reasonably sure that it's in a file called FooBar.java somewhere, so you can do a simple (and cheap) search across file names instead of a (slow, more expensive) full-text search). Except for static initializers, Java classes are just definitions. You don't get to have live code in the top-level scope the way you can with JS or Python or Go. As cumbersome as Java's design decision might feel like it's getting in your way when you're working on your own projects and no matter how much you hate it for making you pay the boilerplate tax, when it comes to diving in to a foreign codebase, it's great when modules are "inert". They don't get to do anything, save for changing the visibility of some symbol (e.g. the
FooBar
ofFooBar.java
). If you want to know how a program works, then you can trace the whole thing, in theory, starting frommain
. That's really convenient when it means you don't have to think about how something might be dependent on a loop in an arbitrary file that immediately executes on import, or any other top-level diddling (i.e. critical functionality obscured by some esoteric global mutable state).
Tags
Annotators
URL
-
- Oct 2021
-
www.microsoft.com www.microsoft.com
-
We would prefer: stay within single host language, but make code lookas declarative as possible.
-
- Jun 2021
-
-
Introduce behaviour that is likely to surprise users. Instead have due consideration for patterns adopted by other commonly-used languages.
-
- Feb 2021
-
en.wikipedia.org en.wikipedia.org
-
Each of the programming language generations aims to provide a higher level of abstraction of the internal computer hardware details, making the language more programmer-friendly, powerful, and versatile.
-
-
en.wikipedia.org en.wikipedia.org
-
In programming language design, a first-class citizen (also type, object, entity, or value) in a given programming language is an entity which supports all the operations generally available to other entities. These operations typically include being passed as an argument, returned from a function, modified, and assigned to a variable.
-