Artima Developer
artima.com · Group blog · on HN since 2007
Artima Developer hosts articles and interviews on software design and programming languages, including talks with Anders Hejlsberg.
What HN saysCommenters recommend it as sometimes useful for programming, and link its 2003 interview with Anders Hejlsberg on language design.
464HN people shared it
294linked it in comments
242stories submitted
3.1Kstory points
7 months agolast shared
2007people per year2026
Most-shared posts
- 1The fate of reduce() in Python 3000 (2005)49 people · 102 points · first shared 2007 · 37 comments on HN
- 2The Trouble with Checked Exceptions (2003)16 people · 68 points · first shared 2021 · 33 comments on HN
- 3Language Design Is Not Just Solving Puzzles (2006)16 people · 24 points · first shared 2010 · 4 comments on HN
- 4Guido van Rossum on removal of GIL: "It isn't Easy to Remove the GIL"15 people · 21 points · first shared 2007 · 5 comments on HN
- 5The trouble with Checked Exceptions (C# architect)13 people · 54 points · first shared 2012 · 76 comments on HN
- 6Five-minute Multimethods in Python12 people · 118 points · first shared 2010 · 48 comments on HN
- 7The DCI Architecture: A New Vision of Object-Oriented Programming (2009)11 people · 74 points · first shared 2009 · 23 comments on HN
- 8Adding Optional Static Typing to Python (2004)7 people · 16 points · first shared 2009 · 1 comments on HN
- 9A Conversation with Anders Hejlsberg (2003)7 people · 4 points · first shared 2012 · discussion on HN
- 10Azul's Pauseless Garbage Collector6 people · 181 points · first shared 2010 · 50 comments on HN
- 11Overview of the new cpp6 people · first shared 2013
- 12Talk with Rich Hickey: Time is the New Memory5 people · 90 points · first shared 2009 · 34 comments on HN
- 13Programming in Scala(2.8), 2nd Ed.(preprint/draft book), Odersky, Spoon, Venners5 people · 35 points · first shared 2010 · 8 comments on HN
- 14Bill Venners chats with the Twitter developers, in Twitter on Scala5 people · 33 points · first shared 2009 · 3 comments on HN
- 15Worse is worse5 people · 32 points · first shared 2009 · 3 comments on HN
What HN people wrote when they linked it
greyman · 2009-05-20
Not best, but sometimes useful:
http://www.reddit.com/r/programming/
http://www.artima.com/
Then there are more good sites, but those are usually focused to certain programming language.
mrkeen · 2025-01-24
I think your points are pretty spot on - most things have already been invented, and there's too much of a move-fast-and-break-things mentality.
Here's a follow-up thought: to what extent did the grey-beards let us juniors down by steering us down a different path? A few instances:
DB creators knew about replicated logs, but we got given DBs, not replicated log products.
The Java creators knew about immutability: "I would use an immutable whenever I can." [James Gosling, 1] but it was years later when someone else provided us with pcollections/javaslang/vavr. And they're still far from widespread, and nowhere near the standard library.
Brendan Eich supposedly wanted to put Scheme into browsers, but his superiors had him make JS instead.
What other stuff have we been missing out on?
[1] https://www.artima.com/articles/james-gosling-on-java-may-2001
o1y32 · 2023-06-11
"the benefit is its performance"
Sure, but when you design a language you are striking a balance between many things (which is why some features could take years to finalize and implement). In this case, the gain in performance is likely minimal, but the confusion and surprise it causes does a lot of damage.
(I recently read through the entire series of conversation with Anders Hejlsberg on the design of C# which is very insightful https://www.artima.com/intv/anders.html)
rileyphone · 2023-01-04
Waldo went on to be the chief architect of Jini at Sun, which IMO is a very elegant solution to the problems of distributed computing. Unfortunately Jini never found success in the real world, but there are a lit of great ideas contained within, like resource leasing, tuplespaces, and interface-based proxying. Here’s a later interview with Waldo that’s a bit of a retrospective [0]. With 20 years passed since then, I don’t think we have yet found a satisfactory approach to distributed systems, so maybe it’s time to revisit these older ones.
0. https://www.artima.com/articles/jim-waldo-on-distributed-computing#par…
pwdisswordfish0 · 2022-09-22
Here's an excellent series where in a 2003 interview, Anders Hejlsberg discusses lots of these types of things and more.
<https://www.artima.com/intv/anders.html>
dtech · 2022-02-22
Java's checked exceptions are generally regarded as a mistake. There's a reason no other languages has them, and newer JVM languages (Groovy, Clojure, Scala, Kotlin) treat all exceptions as runtime. Anders Hejlsberg (creator of Delphi, C# and Typescript) also has an excellent article on their problems [1]. In modern Java I see nearly only runtime exceptions used, especially because that's necessary for most Java 8+ lambda API's.
Especially when used as an error ADT they're awful because they mix everything from "you have to handle this 90% of the time" to "the universe physics just changed, sorry" into one construct. Much better to use something like Vavr's Try and explicitly propagate the error as a value.
[1] https://www.artima.com/articles/the-trouble-with-checked-exceptions
divbzero · 2020-05-29
I dug up that “old email from 10 years ago” which I hadn’t seen before.
Guido laid out the challenges of multiline lambdas on a mailing list [1] and then followed up with a blog post [2] [3]. His chain of thought is worth reading in full, but the crux is lack of “Pythonicity” and his gut feel that named functions avoid the complexity and possible ambiguity of multiline lambdas:
def callback(x, y):
print x
print y
a = foo(callback)
[1]: https://mail.python.org/pipermail/python-dev/2006-February/060621.html "[Python-Dev] Let's just keep lambda"
[2]: https://www.artima.com/weblogs/viewpost.jsp?thread=147358 "Language Design Is Not Just Solving Puzzles"
[3]: https://news.ycombinator.com/item?id=20672739 "Language Design Is Not Just Solving Puzzles (2006) | Hacker News"
joostdevries · 2019-12-18
When designing C# Anders Heljsberg decided against following Java's checked exceptions. You can find his argument against in the interview from 2003 https://www.artima.com/intv/handcuffs.html
kgwgk · 2019-07-12
"In a 1999 report, Van Rossum highlighted the following as his goals for Python:
It should be an easy and intuitive language, just as powerful as major competitors.
It should be open source, so anyone can contribute to its development.
Its code should be understandable as plain English.
It should be suitable for everyday tasks, allowing for short development times."
https://www.computerhistory.org/fellowawards/hall/guido-van-rossum/
“The first sound bite I had for Python was, "Bridge the gap between the shell and C."
So I never intended Python to be the primary language for programmers, although it has become the primary language for many Python users. It was intended to be a second language for people who were already experienced programmers, as some of the early design choices reflect.‘
https://www.artima.com/intv/pyscaleP.html
benatkin · 2019-06-23
The invention of programming languages is well trodden territory. The original author of this site has written about it: http://www.paulgraham.com/popular.html
It's hard to get excited about V if you've studied a lot of programming languages and watched some new ones come into use. I also recommend the Artima articles with the designer of C#: https://www.artima.com/intv/anders.html
alayne · 2018-12-18
It was though
https://www.artima.com/intv/pyscale.html
"So I never intended Python to be the primary language for programmers, although it has become the primary language for many Python users. It was intended to be a second language for people who were already experienced programmers, as some of the early design choices reflect. On the other hand, intuitively I probably stuck to many of ABC's design principles. Because although I had my criticisms of ABC, I borrowed many of its valuable elements, which eventually made Python a great language for people who aren't ace programmers or who are just learning. We now have a large community of people using Python as an educational language, teaching Python in schools. These people aren't and may never be professional programmers, but they still find some programming skills useful." -GvR
junke · 2018-07-06
My problem with the slogan is that it has become a catch phrase for those who either haven't read the original article, or have read it and either have forgotten what it really talked about or never understood it in the first place. As a catch phrase, it is often used to justify shoddy design, or following the crowd rather than doing what is right, or as short-hand for the real claim that our customers are too stupid to either appreciate or deserve high quality products. Why spend the time doing things right, this line of reasoning goes, when we all know that worse is better. You are far better off giving the customer something that you know is less than what you could produce, because they (those simple customers) will think that it is better.
Worse is Worse (Jim Waldo)
https://www.artima.com/weblogs/viewpost.jsp?thread=24807
ianopolous · 2017-09-17
They claim there are no lock-free or wait-free GCs. But Azul have had a pauseless one for the best part of a decade:
http://www.artima.com/lejava/articles/azul_pauseless_gc.html
pitay · 2016-06-01
Ah this reminds me of all the different proposals for closure syntax in Java before it was implemented, the following links put compare some of the proposals:
1. http://www.artima.com/weblogs/viewpost.jsp?thread=180638 (Inner Classes or Closures)
2. http://www.artima.com/weblogs/viewpost.jsp?thread=182412 (Clear, Consistent, and Concise Syntax (C3S) for Java)
3. https://www.artima.com/weblogs/viewpost.jsp?thread=202004 (Comparing Inner Class/Closure Proposals)
PS. I remember the Artima articles because I liked them at the time.
jfim · 2015-06-30
It's not as if it's the first time Apple does it either. They positioned OS X as the best platform to run Java, yet ditched it a couple of years later. Even back then, people were complaining about it [0].
Developing on Mac has always been a chore (at least back in the XCode 1.1 and 2.0 days), with poorly documented APIs and APIs that are just flat out broken (OpenGL comes to mind, and is still broken to this day apparently).
Our running joke back then was that "Macs are very user friendly, except developers don't count as users." Still true to this day apparently.
[0] http://www.artima.com/weblogs/viewpost.jsp?thread=13058
nickbauman · 2015-04-30
Ken Arnold said it best in his "Style is Substance"
http://www.artima.com/weblogs/viewpost.jsp?thread=74230
edtechdev · 2015-01-21
The same thing seems to happen in many mailing lists or newsgroups once they reach a certain size, as well as on discussion boards, stackoverflow, and other sites like wikipedia. One person called them 'RTFM jerks': http://www.linuxtoday.com/infrastructure/2006033100126OPCY
On the python lists, they were called NIMPY ("Not in my Python!"): http://www.artima.com/weblogs/viewpost.jsp?thread=87182
You combine a power structure (control over others in some respect) with pseudonymity and you'll accelerate this problem. Even without a power structure, people will try to dominate, bully others, by posting more frequently than anyone else in an effort to drown out other opinions or contributions. The anonymity disinhibits this behavior further (called the "greater internet fuckwad theory"): https://en.wikipedia.org/wiki/Online_disinhibition_effect
eranation · 2014-10-07
I use scala a lot and it did become my go to general purpose language (as well as my workplace adopted it as a first class citizen and used for many new projects)
I do have issues with it, but mostly with developers using (abusing) it. (And library authors that are a bit religious about the functional paradigm and simply love their operators...
With great power comes great responsibility, the is no better description to this language.
Also, I was looking at the CanBuildFrom hell with fear, but Odersky et al's book on Scala surprisingly did a good job getting the pieces in place for me. It even makes sense of the madness.
http://www.artima.com/shop/programming_in_scala_2ed
Finally, Bozho is one of my most respected contributors on stackoverflow. And I can say that his slides actually do justice to Scala, I might disagree on the conclusions, but the facts are absolutely right.
danabramov · 2014-06-15
>However, I ran up against the lack of generic protocols myself today (for those with access, there's an interesting debate at https://devforums.apple.com/thread/230611?tstart=0). It seems like a deliberate design choice, but one I'm not really sure about.
So did I! A few more related links if you're interested in this question:
http://schani.wordpress.com/2014/06/11/associated-types-considered-wei…
http://www.artima.com/weblogs/viewpost.jsp?thread=270195 (this is about Scala, but Swift somewhat follows Scala with this design)
https://groups.google.com/forum/#!topic/swift-language/3PtydRXR0ao
nairteashop · 2014-05-09
> I'd love to see optional typing in Python, I wonder if there is any official reasons about why it never got introduced.
Here are a few from Guido himself (not really anti static-typing, but just walking you through pros/cons as he sees them). Great reads:
http://www.artima.com/weblogs/viewpost.jsp?thread=85551
http://www.artima.com/weblogs/viewpost.jsp?thread=86641
http://www.artima.com/weblogs/viewpost.jsp?thread=87182
adolgert · 2013-11-07
Meyers' presentation slides, with notes, are available and excellent: http://www.artima.com/shop/overview_of_the_new_cpp. They include C++14. It isn't the deep dive, but it's a great overview.
halayli · 2013-11-07
I highly recommend this: http://www.artima.com/shop/overview_of_the_new_cpp
By Scott Meyers
bad_user · 2013-06-03
In practice there are also hybrids that try to delay long stop-the-world phases as much as possible, but still need to stop-the-world when compacting the heap, like JVM's CMS.
And I was under the impression that there already are GC implementations that never go into stop-the-world phases, like Azul's Pauseless GC [1]. There's also the new G1 from JDK 7 that promises to make pauses fewer and more predictable than CMS, while avoiding many memory fragmentation issues that CMS has (how well that works out in practice, remains to be seen, as it's not fully matured at this point).
Btw, I love how Rust is trying to solve memory management issues by reinventing the problem. That's what new languages should do, instead of reimplementing other languages poorly.
[1] http://www.artima.com/lejava/articles/azul_pauseless_gc.html
gtani · 2013-05-22
Benchmarking on the JVM is tricky, beyond pure algorithmic efficiency (assuming all memory accesses are equal), there's cache effects, JVM heap and GC effects and the usual warmup/inlining concerns of benchmarking. On page 551 of the excellent scala staircase book (2nd edition[1]) there's a collection efficiency table w.r.t. head/tail/indexing/insert, but that's a jumping off point (sorry, I can't find an online version of the table).
[1] http://www.artima.com/shop/programming_in_scala_2ed
e12e · 2013-03-14
I found this:
http://proceedings.informingscience.org/InSITE2012/InSITE12p165-187Bul…
Among other things, it includes a long list of references -- taken after searching based on:
http://mango2.vtt.fi/virtual/agile/publications.html
That again was referenced in the following blog post from 2007, that I found more interesting (if rather similar) to op:
http://www.artima.com/weblogs/viewpost.jsp?thread=216434
irahul · 2011-08-12
> Have you ever heard Guido speak about the issue?
Yes.
> He and a number of others don't think it's one worth solving. Really.
Check your claims.
http://www.artima.com/weblogs/viewpost.jsp?thread=214235
http://docs.python.org/faq/library#can-t-we-get-rid-of-the-global-inte…
sorbits · 2011-07-18
Same guy also did a hasted post criticizing Ruby¹ so I wouldn’t really put anything into his “first look” at a programming language.
¹ He removed his first post and did a less negative follow-up: http://www.artima.com/weblogs/viewpost.jsp?thread=146091
ondrasej · 2011-05-12
Definitely Programming in Scala - http://www.artima.com/shop/programming_in_scala. You might find some parts of the book a little boring if you already have experience with functional programming, but it is one of the best books about programming languages I've read (I've only read the second edition, not the one that is available online, but I guess, the first one will be OK as an introduction too).
julian37 · 2011-01-22
* Read the summary of changes in Python 3: http://docs.python.org/release/3.0.1/whatsnew/3.0.html
* See Guido Rossum's Transitional Development notes here: http://www.artima.com/weblogs/viewpost.jsp?thread=208549
* Read Mark Pilgrim's excellent chapter from Dive into Python 3: http://diveintopython3.org/porting-code-to-python-3-with-2to3.html
* Use Python 2.7 and turn on deprecation warnings.
EDIT: Found this great guide to forward compatibility:
* http://www.slideshare.net/regebro/python-3-compatibility-pycon-2009
beaumartinez · 2010-09-11
Interesting ideas. You just reminded me of a post Bruce Eckel wrote on what programming might be like in the mid future; he touches on some similar ideas. I recommend you give that a read to see what you think as I found it quite thought-provoking.
http://www.artima.com/weblogs/viewpost.jsp?thread=284730)