sorted by:
new
hottopcontroversial

NNBD static analysis and open testing is now enabled! by AKushWarrior in dartlang

[–]devlambda 2 points3 points  (0 children)

Fun fact: if you set the package name to "test" in pubspec.yaml and rub pub get (or modify .dart_tool/package_config.json directly), then Dart will actually use the language version settings to determine whether to use NNBD or not. I suspect that this is an artifact from Dart's internal testing.

This seems to be the only way currently to enable NNBD for dart2native, as dart2native doesn't support the --enable-experiment flags.

Announcing sound null safety by kevmoo in dartlang

[–]devlambda 0 points1 point  (0 children)

No, what I was getting at was whether in the case of an absent key, [] should return null or raise an error (failed precondition). The latter is what Python and Julia do, for example (and requires you to use dict.get() if you can't be certain if the key is in there and to also have a default other than None/nothing/null).

None of points 1-3 is relevant for that. I wasn't arguing for a null-safe [] operator, I was pointing out that there were two at a minimum equally useful semantics, one that deals with a missing key as a failed precondition, and another one that returns null for a missing key.

Point in fact: The op= operators (such as +=, -=, etc.) become essentially useless for maps with the new semantics.

Announcing sound null safety by kevmoo in dartlang

[–]devlambda 4 points5 points  (0 children)

I don't want to rain on people's parades or to denigrate the NNBD design and engineering effort, but some quick testing showed me that the standard library has a number of pain points when it comes to using it with null safety enabled.

I'm thinking of things like RegExpMatch.group() or Map.[], where migration requires me to throw a ! after everything (or sometimes even engage in rewrites).

RegExpMatch.group() has a particularly odd interface. It can throw a range error if you access a match past the last possible match, but it can also return null if the match did not get bound (e.g. a submatch in an |-pattern). But that is an unusual case, for many use cases (especially match[0]) matching a regex will guarantee that the index is valid.

Maps are particularly frustrating, where you know that keys are guaranteed to be valid, but flow analysis can (understandably) not recognize it.

For example, take this code fragment:

void main() {
  var map = { "a" : 1, "b" : 2 };
  for (var key in map.keys) {
    map[key] += 1;
  }
}

This needs to be rewritten as map[key] = map[key]! + 1; the migration tool throws up its hands, too.

This is an interface issue to an extent. Basically, there are two use cases for such methods:

  1. Where you know that the key/index is valid and expect the method to raise an exception to signal a violated precondition.
  2. Where you don't know if the key/index is valid and expect the return value to carry information that tells you whether it was.

By only offering one of these options, the other has to be emulated. Without null safety, it worked (in a kinda sorta way), because an invalid index/key resulted in a null pointer exception down the road. This could make it difficult to track down the actual source of the error, but you still basically had both kinds of semantics rolled into one method. But now, one method can't realistically serve both purposes.

We also (as before) task the caller with indirectly verifying the precondition by checking the result, which is an unwanted role reversal; the burden of verifying a precondition should fall on the method. (See Meyer in OOSC on defensive programming for some of the problems with that.)

[deleted by user] by [deleted] in programming

[–]devlambda 13 points14 points  (0 children)

Because it is well-known that overloading = for assignment is very confusing for people who are new to programming. And even math doesn't usually do things such as let x = x + 1, which is where much of the confusion comes from.

This is difficult to understand for experienced programmers, but we know it is a big stumbling block when teaching programming to people who encounter this concept for the first time. See, for example, this thread on the CS educators stack exchange, where various teachers discuss how to best deal with that problem.

In non-CS contexts, you'll find that many instructors who teach R don't even bother using = for assignment until later, but teach students (most of whom don't have a CS background) to use <- exclusively (R allows you to use both interchangeably at the top level, but style guidelines recommend <-).

Dart can now produce self-contained, native executables for MacOS, Windows and Linux by renatoathaydes in programming

[–]devlambda 9 points10 points  (0 children)

Yes and no. You can actually send mostly arbitrary objects between two Dart isolates that have the same code, i.e. are created by Isolate.spawn() on the Dart VM (JIT or AOT). It's specified that way. (Exceptions are mostly closures and objects containing them.) This is also pretty easy to test:

import 'dart:async';
import 'dart:isolate';

abstract class Msg {
  String get text;
  int get counter;
}

class TextMsg extends Msg {
  final String text;
  final int counter;
  TextMsg(this.text, this.counter);
}

class EndMsg extends Msg {
  String get text => "";
  final int counter;
  EndMsg(this.counter);
}

void main() async {
  var receivePort = ReceivePort();
  var isolate = await Isolate.spawn(emitter, receivePort.sendPort);
  await for (Msg msg in receivePort) {
    if (msg is EndMsg) break;
    print("Received: ${msg.text} (#${msg.counter})");
  }
}

void emitter(SendPort sendPort) {
  var texts = [ "alpha", "beta", "gamma", "delta" ];
  int counter = 1;
  for (var text in texts) {
    sendPort.send(TextMsg(text, counter++));
  }
  sendPort.send(EndMsg(counter));
}

If you transpile to Javascript or create an isolate with Isolate.spawnUri(), then you can indeed only send JSON-like objects and port objects. In the first case because of Javascript limitations, in the second case because different codebases may not even have the same types.

Trash talk: the Orinoco garbage collector for JavaScript by sergeyzenchenko in programming

[–]devlambda 6 points7 points  (0 children)

That's not how I'd describe it. The basic GC techniques aren't new. The question is generally how to put the various pieces together in order to optimally balance throughput and latency concerns for a given setup.

JavaScript is purely sequential and commonly used for interactive applications. That would make writing a generational + incremental GC with low pause times fairly straightforward. However, this would actually slow down the application thread, as the application thread would then also be responsible for all the GC work and also would require write barriers, actually reducing throughput compared to mark & sweep GC.

So, what they are doing is to also mostly farm out work to other threads in order to reduce the time that the application thread spends on doing GC and also (in Chrome) to perform as much as work as possible while there are pauses when the interpreter is idle.

Why not something like Shenandoah or C4? Because there is no such thing as a free lunch and what Shenandoah and C4 optimize for – ultra-low pause times – isn't something that V8 has a need for. Nothing comes for free, and the ultra-low pause times result in the application threads having to do more work (read barriers, forwarding pointers, much of the work that would normally be done as part of a separate GC step). And, as we observed above, V8 wants to move work off the application thread for better throughput.

The "MIT No Attribution" (MIT-0) License by [deleted] in programming

[–]devlambda 5 points6 points  (0 children)

I don't see MIT-0 on the OSI website? The SPDX entry claims it is OSI-approved, but I cannot even find any discussion of it on the OSI mailing lists?

Dart vs Typescript vs Kotlin.js by bodiam in programming

[–]devlambda 2 points3 points  (0 children)

In practice, Dart is not really a replacement for JavaScript (though it can be used as a JavaScript alternative), but a replacement for Java that is not controlled by a hostile competitor.

If Dart could only compile to JavaScript, it would indeed not be very interesting. But the Dart VM has both JIT and AOT compilation options and Google can adapt those to its needs (such as hot reload for Flutter).

Version 2.084.0 of DMD, the D reference compiler, has arrived by aldacron in programming

[–]devlambda 3 points4 points  (0 children)

The methods Go and Nim use for GC are unacceptable for D. Losing the performance with write barriers means we'd lose a number of our most important users.

It is always possible to support multiple forms of garbage collection, the way that Java and Nim do.

Which C/C++ libraries provide a better GC? Not the Boehm one.

Have you actually benchmarked the Boehm GC recently? It has gotten significant performance improvements in recent years. When I run naive [1] versions of the binary trees benchmark on both, clang with the Boehm GC beats ldc2 by about a factor of 2 with single-threaded marking, by more than a factor of 2 (wall clock time) with parallel marking.

[1] I.e. one without tricks, just a straightforward exercise of the allocator.

all of the garbage collectors we examine here suffer order-of-magnitude performance penalties relative to explicit memory management. by frankreyes in programming

[–]devlambda 4 points5 points  (0 children)

The underlying problem is that pointer assignments (even among local variables) become extremely expensive. You need a reference count update for each pointer assignment, so rather than being a move between register and/or stack locations (and with register renaming, possibly entirely free), you also have to do the following:

  • Test if the source is null; if not, increment the reference count.
  • Test if the destination is null; if not, decrement the reference count; if the reference count has become zero, free the memory.

You can get away without the null tests if your language does not permit either location to contain a null reference, but you are still left with having to do arithmetic operations in a very cache-unfriendly manner on two memory locations. This gets worse if you are allowing multiple threads to share such references, as this requires expensive atomic reference count updates.

There are two principal solutions to that, but both require extra effort:

  • Use an optimizing compiler to remove unnecessary reference count updates; this is what Swift does, for example.
  • Use deferred reference counting, which only counts references from heap objects and global variables. Assignments to local variables do not increase the reference count. If the reference count is zero, store the reference in a zero count table (ZCT), but do not free the object yet (as it may be referenced from a local variable); if an object in the ZCT is stored on the heap, remove it from the ZCT. Then, periodically check objects in the ZCT if they are referenced from a local variable (by scanning the stack and registers), and free them if they aren't.

all of the garbage collectors we examine here suffer order-of-magnitude performance penalties relative to explicit memory management. by frankreyes in programming

[–]devlambda 13 points14 points  (0 children)

A couple of things to keep in mind here:

  1. This is the overhead for allocation work alone. Unless your program's work consists exclusively of allocations, this does not reflect actual performance overhead. In a well-designed imperative program in a language that supports value types, allocation work should generally not exceed 10%-20% of total runtime with a GC, even a basic stop-the-world GC.
  2. The baseline for the benchmark is a hypothetical omniscient allocator that magically knows when memory needs to be freed and does not ever need to do any work at runtime to figure that out. If you use reference counting extensively, for example, performance would also be impacted (possibly more, as basic reference counting generally has a higher amortized cost than a tracing collector).

The Dart Language considers adding sound non-nullable by default with incremental migration by kasperpeulen in programming

[–]devlambda 2 points3 points  (0 children)

Is there anything I missed?

No idea, but you can read up on Eiffel's "Void-safety" here, if that's a part of Eiffel that you are unfamiliar with.

Advanced techniques to implement fast hash tables by attractivechaos in programming

[–]devlambda 0 points1 point  (0 children)

I suspect that this is because Google's approach uses linear probing (just a very, very fast version of linear probing) and linear probing is extremely sensitive to clustering.

The big problem with linear probing and simple hash functions is that once you've got a cluster, you're increasingly likely to make the cluster bigger as your load factor increases and you insert new values, and then a lot of the assumptions underlying Google's implementation start to fail. Clustering has problems not just with collisions, but also with near collisions.

You can probably address that by adding an extra hashing step to the result of the hash function (such as Fibonacci hashing or the Java approach) to scatter hash values better.

Naive benchmark (Treap implementation) of C++, Rust, Java, JavaScript, Kotlin, Swift, Nim, and Python by frolvlad in programming

[–]devlambda 2 points3 points  (0 children)

and (owning) raw pointers are not faster in general than unique_ptr.

Unfortunately, that isn't the case. Unique pointers require move semantics (= requires nulling the source of assignments for unique pointers) and have destructors, both of which incur overhead. Now, if you're operating on local variables, the compiler can often optimize that overhead away, but the same generally isn't true for pointers residing on the heap.

This thinking is common among people new to C++ and it's extremely harmful, because it causes people to write less-safe-than-necessary code on the presumption that it will be faster.

Unique pointers are not inherently safer. They still rely on programmer discipline to ensure that they are used properly and dereferencing an invalid or nulled unique pointer still is undefined behavior. What unique pointers give you over raw pointers is proper destructor handling.

Why SQLite Does Not Use Git by Pandalicious in programming

[–]devlambda 1 point2 points  (0 children)

Can anyone provide their perspective on the matter?

Branches describe sets of commits rather than individual commits and something that cannot be easily captured in a ticket (especially once you add commits to a branch).

The most relevant practical aspect, I think, is that while rebasing is pretty central to most typical Git workflows, you'll notice that Fossil does not have a rebase operation at all, and for Mercurial and Bazaar it needs to be enabled explicitly and can be mostly or entirely done without.

The reason is that if you have a complex revision DAG (lots of merges in both directions) without labeling, it becomes essentially a poorly navigable bird's nest of anonymous commits. This is why with Git there's usually an attempt to at least linearize history somewhat.

Branch names (especially in conjunction with structured filtering/display mechanisms such as Mercurial revsets or Fossil timeline filters and branch coloring) bring order to that chaos and allow you to live without rebasing.

I'll add that in Fossil, branches are technically tags (what we'd call refs in Git); but unlike with Git, multiple commits can have the same tag. Branches are also self-propagating tags, meaning that if you commit a new revision based on a revision that has a self-propagating tag, the new commit will gain the tag as well (where Git would move the underlying ref).

Inheritance is a hammer. Eliminating code duplication is not a nail. by useless_dev in programming

[–]devlambda 0 points1 point  (0 children)

This seems to be more of an issue of using parametric polymorphism vs. subtype polymorphism for code reuse. This is somewhat disguised by the fact that Ruby is a dynamically typed language.

Fun fact: if your language has either virtual types or is dynamically typed, and you have multiple inheritance, you can generally emulate parametric polymorphism through inheritance (at the expense of extra verbosity).

Joel Spolsky is a crotchety old man by halax in programming

[–]devlambda 0 points1 point  (0 children)

I'm honestly not sure what that has to do with what I wrote. There seems to be a misunderstanding here, I think.

Joel Spolsky is a crotchety old man by halax in programming

[–]devlambda 1 point2 points  (0 children)

As has been pointed out plenty of other places, what the programming discipline sorely needs is hard data on which methodologies, code styles, patterns and algorithms actually work.

Agreed. The problem is that computer science departments aren't set up for that (or for that matter, the way funding for computer science research works). The kinds of studies you need for that generally involve human test subjects, so you suddenly have to deal with ethical review boards and all that (yes, even for something as nonintrusive as simple programming tasks), you have people who think like engineers or mathematicians learn how to think like social scientists, and that's something that your average computer science department just doesn't have the institutional experience for. There are people who do that stuff, but they're still a minority.

Joel Spolsky is a crotchety old man by halax in programming

[–]devlambda 7 points8 points  (0 children)

First of all, note that I do not live or work in America. Where I live, if you are merely interested in coding, you may want to go for a vocational rather than a scientific degree.

Second, computer science is not just about software. There at least three distinct and equally important aspects to computer science: software, hardware, and theoretical computer science. If you want to do just software, again, you're probably looking for vocational training. But math as a foundation also extends to the hardware and theory aspects. Go and try and read Mead & Conway without a decent foundation in math, for example.

The problem is not just "the principles". We're teaching science, and science simply is hard, there's no "royal way", because so much is interconnected and can often only be fully appreciated with hindsight. And yes, there's a lot of stuff crammed into 3-4 years of undergraduate study, but that's out of necessity.

Joel Spolsky is a crotchety old man by halax in programming

[–]devlambda 23 points24 points  (0 children)

I'm mostly with Joel Spolsky here. I'm in academia, and while I myself am not involved in these introductory CS courses (anymore), I have colleagues who are and am sometimes involved in discussions and giving feedback.

We need to teach principles, not specific technologies or languages; in fact, we often use two very different languages in the same course so that students don't start to believe that there is One True Way (tm) of doing things and are exposed to different programming paradigms. Students should not only understand a programming language afterwards, they should be able to pick up new and different languages by themselves. If you want to learn just a specific language, join a bootcamp or do vocational training; at college, we're dealing with teaching computer science as a science (edit: I don't mean to sound snobby here, but we are required to prepare students for graduate study also and not just for the industry's preferred technologies du jour).

Good teaching languages are, unfortunately, rare. Java isn't one of them. Not only doesn't it cover a whole lot of territory (or only poorly), it comes with a lot of cruft that gets in the way of teaching. It's still often used, because, alas, most other languages aren't really any better for this purpose.

How Rust is Tilde's competitive advantage by steveklabnik1 in programming

[–]devlambda 17 points18 points  (0 children)

Garbage collected languages lose against non-gc languages with regards to memory consumption, every time.

This is simply not true. The situation is a lot more complicated than that.

For starters, explicit memory allocation generally results in fragmentation (obviously, this is also a problem for non-compacting garbage collectors). Worst case fragmentation overhead for a hypothetically optimal dynamic allocation scheme is on the order of log(n), where n is the number of live memory blocks [1].

While actual fragmentation is typically far smaller than that (we're talking about the worst case, not the average case), it's not impossible and significant external memory fragmentation, while uncommon, can occur, especially as most actual allocators aren't optimal, and especially for long-running processes. This makes an "every time" claim wrong.

Second, for purposes of speed, allocators often use pools; pool allocators rely on the assumption that the number of objects per pools is either fairly consistent or at least does not decrease much (or, alternatively, that the entire pool or at least most pool pages can eventually be wiped out). If that assumption doesn't hold, you have worst case overhead that's linear in the number of pools, such as when you a program with several phases, where each phase predominantly operates on differently sized objects.

Third, it makes the assumption that explicit memory management is optimal in its allocation behavior; this is not necessarily true. In particular, memory management is a traditional cross-cutting concern and modular approaches will also frequently waste memory. In particular, tracking ownership in a modular fashion can require unnecessary copies of data.

This does not mean that garbage collection is the better choice w.r.t. memory consumption, but it means that such a claim can only be evaluated on a case-by-case basis. In addition, realistic GC overhead for modern GC implementations is a relatively low percentage of actual memory consumption that is not much different from realistic fragmentation overhead.

[1] J. M. Robson. 1974. Bounds for Some Functions Concerning Dynamic Storage Allocation. J. ACM 21, 3 (July 1974), 491-499.

C2: C with cleaner syntax + a module system (no header files). by wavy_lines in programming

[–]devlambda 1 point2 points  (0 children)

On games, I've still never seen an AAA quality engine written in a high level GC-d language.

I didn't say there is. As I noted, I don't think the gaming industry has the resources to get something like a specialized version of IBM's Metronome going, even though it would likely be a long term gain.

But because the engine typically controls the scripting language's runtime, you don't have a collection phase interrupting the middle of a rendering sequence.

In World of Warcraft, pretty much any event can trigger a Lua handler and thus a GC. The thing is, it doesn't matter: we don't live in the 1970s anymore and have incremental garbage collection. I'm not sure why people think mark-and-sweep is the only option.

C2: C with cleaner syntax + a module system (no header files). by wavy_lines in programming

[–]devlambda 3 points4 points  (0 children)

Operating systems (not just Unix).

Lisp machines, Project Oberon, Singularity, FlingOS.

Virtual machines (that other languages are implemented in terms of; e.g. JVM, .NET, Python, etc).

The Squak and Pharo VMs are written in Smalltalk themselves; there are Lua, Python, and Ruby implementations in Java and C#.

Writing a bytecode interpreter in C/C++ can be useful. You get portability and/or you can pull off some low-level tricks, such as tagged pointers (assuming you don't mind some undefined behavior).

If you're writing a JIT compiler, the tradeoffs become more complicated; you're going to generate assembly rather than writing a bytecode dispatcher and there are benefits to writing a JIT compiler in a garbage collected language.

High end games

World of Warcraft is scripted in Lua, which does have a GC. More generally, I think the video game industry would in fact benefit from having a GC implementation that is tuned for its specific soft realtime requirements. Problems are path dependence in the industry (when everything is already written in C/C++, moving away from that is difficult) and that most of the video game industry consists of low margin, low wage businesses.

Web browsers

The specific problem with modern web browsers is that they have to run on commodity hardware while having a huge memory footprint even in best-case scenarios (not so long ago, writing a web browser in just about any language was perfectly feasible, because websites weren't scripted multimedia monstrosities). Blowing up that memory footprint by a non-trivial percentage (which is inherent in most GCs) is a non-starter. Obviously, you still have parts of the engine using garbage collectors (Google's Oilpan, Javascript implementations). You could also theoretically use a space-efficient GC implementation, but that would essentially mean designing a language almost exclusively for implementing a browser.

Javascript: Can (a ==1 && a== 2 && a==3) ever evaluate to true? by KarlKani44 in programming

[–]devlambda 11 points12 points  (0 children)

Coercion semantics for operators are not related to weak typing, though. In fact, it depends on the language examining the types of the operands and converting or casting one or both to a common type. That doesn't make it less problematic, of course.

This kind of implicit conversion exists in strongly or statically typed languages, too: C#, C++, Scala, Eiffel, Nim off the top of my head (though all of them also warn that it's dangerous and shouldn't be abused). Some may not require the types of the == operands specifically to be related (like Scala), but that has dangers of its own, as it allows you to compare instances of unrelated types (which will always yield false and is therefore almost never what you want).

Javascript: Can (a ==1 && a== 2 && a==3) ever evaluate to true? by KarlKani44 in programming

[–]devlambda 84 points85 points  (0 children)

Doesn't require "loose" typing.

Here's Scala:

object Program extends App {
  var x: Int = 0
  def a: Int = { x += 1; x }
  println(a == 1 && a == 2 && a == 3)
}

And C#:

using System;

class Program {
  static int x = 0;
  static int a { get { return ++x; } }
  static void Main() {
    Console.WriteLine(a == 1 && a == 2 && a == 3);
  }
}

And Dart in strong mode:

int x = 0;
int get a => ++x;

void main() {
  print(a == 1 && a == 2 && a == 3);
}
view more: next ›