41–50 of 75 posts
iirc that's something where you don't store data chopped up into objects, but have arrays that keep all the data of one "aspect" of all "objects"... or something like that. something game programmers would use, helps avoid cache misses.
is that what he was talking about? if so, what does it have to do with macros?
Earlier quoted context omitted.
Actually, from a math perspective, it's kind of nonsensical to talk about type conversion at all. That is, 3, 3.0, and 3/1 are purely notational differences, and all three represent exactly the same object. Since math is theoretically infinite precision, the way you write a number has no impact on the way operations like division act on it, making whether it belongs to Z, or just Q or R a moot point. Now, if you rest…
Kind of. But you might say that rational numbers are ordered pairs of integers and positive integers, real numbers are Cauchy sequences of rationals, and complex numbers are ordered pairs of real numbers, and the real number 3 can't be added to (2+i) without converting it to a complex number first.
Type conversion is more like if you had the written number 3 and a picture of the point 5 on a number line and someone told you to add them. Naturally, you would write 5 as a number first, because you don't have a useful way to add a number and a picture. But this doesn't change the results of adding the quantities 3 and 5; it's purely an artifact of the way the information was presented to you.
Clojure and Scala are both there, except on idiomatic libraries (you might have to use Java libraries). Clojure wins on simplicity of syntax (Scala has a rule that operators ending with ':' associated to the right, which makes an incredible amount of sense once you understand the language but is annoying and arbitrary to beginners) and homoiconicity. Scala wins on pattern matching and robustness (static typing). I'd…
Earlier quoted context omitted.
I find it interesting that two of the most exciting languages that exist right now are built on top of the VM for one of the worst ones.
The strength of Java for many years has been the platform, and indeed the surrounding ecosystem, not the language. In that sense it's no surprise that there is a lot of effort going in to providing better languages on that platform.
The problem with Java libraries w.r.t. modern high level languages is that Java libraries are built on Java abstractions. It doesn't matter how high level the new language is, but when interfacing with Java libs, you have to stick to single dispatch object oriented programming. So in the end, there are many cases where you use the Java library through some wrapper layer written in Clojure or your Clojure code ends up looking a lot like Java.
Once you add a wrapper layer shim between your preferred language and the platform, it doesn't matter what's underneath. That's why I like to stick to languages that are built on native code and libraries, C and Posix and Unix API's with some Linux and/or BSD additions. Of course, if you want to run on Windows, all the code has to be duplicated since Win API's are different.
This just seems like an everything and the kitchen sink list. I am not convinced supporting every possible use case leads to an approachable/efficient language. It seems akin to arguing my car should also be a boat and an airplane.
How far is Python from this list? Macros are missing but the remaining list seem close to me.
3 / 2 == 1
Earlier quoted context omitted.
How far is Python from this list? Macros are missing but the remaining list seem close to me.
Math sucks a lot in Python 2.7: 3 / 2 == 1 Python 3 fixes that, thou, but still it uses floating point numbers instead of rational numbers.
Most languages have most of the listed features. The most interesting uncommon idea on that list to me is model of time. But only when it allows reversible computing. I don't know how practical that is though. Anyways I've separated out the parts of the list which I think are less common. And listed examples off the top of my head so by no means is the below meant to be exhaustive. The uncommon ones: * Units - F# and…
Just some notes from a Scala user:
Regarding Units: I bundled some work done before by other people into a nicer package/syntax, apart from a few missing bits working with Units looks quite nicely in Scala, even without any special support for it:
val mass: Mass[Double] = 4.0 kg
val longMass: Mass[Long] = mass asLong
val length: Length[Int] = (5 m) * 3
val time: Time[Int] = 1 s
val doubleTime: Time[Int] = time + time
val temp: Temperature[BigDecimal] = BigDecimal("22.22") k
val speed: Speed[Int] = length / time
val area: Area[Int] = length * length
val volume: Volume[Int] = (23 m) * (1 m) * (1 m)
val smallVolume: Volume[Double] = (volume asDouble) / 12.0
val area2: Area[Int] = volume / (23 m)
val accel: Acceleration[Double] = (10.0 m) / ((2.0 s) * (1.0 s))
val accelNum: Double = accel toDouble
Scala will very likely get macros in the next version, together with pluggable types/type providers. Macros not in a Lisp or "extend syntax" sense, but more in a Nemerle sense. Scala macros are written in fully statically typed Scala and are checked at compile time before and after expansion.
Sometimes you need specific file format, compatibility between languages, customization, etc - then pickle is not enough. But for my uses pickle was good enough most of the time, and it's stupidly easy to use. No need to change your code in any way. That makes one-off cashing of intermediate results to file system manageable, implementing save/load game is 3 lines of code (counting import). I love it, and I miss it in every other language I use.
Javascript has JSON, but writing general code to serialize arbitrary object graph with cycles, functions as field values, properly storing prototype chains, etc is still hard.
hmm, what exactly does he mean by data-oriented programming? iirc that's something where you don't store data chopped up into objects, but have arrays that keep all the data of one "aspect" of all "objects"... or something like that. something game programmers would use, helps avoid cache misses. is that what he was talking about? if so, what does it have to do with macros?
http://www.faqs.org/docs/artu/ch09s01.html
More data (and data structures) and less code. It's very common in Lisps and other homo-iconic languages.