mmfZ4e4OqQ7RRwP
mmfZ4e4OqQ7RRwP on Hacker News
That doesn't make much sense, think about lag, playing with somebody who is far enough that the speed of light makes a difference. You want a near real time graphics pipeline for each user to avoid vomiting, but other than that you will still get terrible terrible network problems one way or another which you can't control and will show up as ghosts in the game, stopped players, etc.
Not only that, by abstracting cross platform commands for things like git you give up the knowledge which allows you to go to other platforms and work there. Unless this mac thing would be ported to linux, windows, etc.
It's definitely an improvement, but most of the syntax complexity seems to come precisely from supporting all the annoyances of Objective-C.
The feature I most miss from other programming languages like Nim is meta programming. In Objective-C you had synthesized properties to generate all the boilerplate code, but in Swift you don't, so to copy certain Objective-C patterns you have to manually write your own private instance variable plus a computed property to control access and side effects. Stuff which is trivially hidden behind a macro. Come on, even Java allows use of annotations to generate code at compile time on Android.
Of course you can argue then that maybe Swift code should not use Objective-C patterns, but hey, I'm still porting and learning. And maybe Swift 2 by the end of the year will have this feature, just like the usage of the where keyword inside conditionals was added recently in 1.2.
I also dislike that there are no forward declarations, so instead of being able to put all your class public API in a single block you have to mingle it with setter/getters' implementations. I guess it's time to use a documentation generation tool and read that instead of reading header files.
I'm going through half of Swift's ebook rewriting an old objc program in the process and the amount of syntax special cases is just mind boggling. So far the worst offender to me feels the use of the where keyword inside branched let assignments. Example: ``if let a = optionalValue where a.someFieldString = "hello" { ... }``. In general the ``where`` keyword signals they ran out of ideas designing the language.
When I present myself to people I use one form of my name. Some people I know use nicks. Others use part of my formal name. Due to me being a foreigner, essentially everybody I know uses a slightly different way to name me or pronounce the same name. However, there is consistency. Each person will use the same form for naming me.
This happens with Nim code too. Each programmer will have their convention, and will use it consistently. If you have a team, you establish a convention for the project: you need that anyway because people creating new stuff need a consistent way of naming things and you don't want to later rename everything after a heated discussion. So if you can't keep people on your team from using a project convention, you have a bigger problem than slightly different identifiers in a programming language.
Also, once you start using the different free naming conventions in Nim you grow inmune to them looking ugly. Just like when you know only one programming language everything else looks alien, but when you learn something else you expand your horizon and it stops looking so alien, and it stops being "harder to read". I jump from one convention to another without problem for each project as needed, and doesn't even bother me at all.
tl;dr it's not a big deal, don't let that stop you from learning a very nice language, you could regret it later
I don't know anybody who redistributes source code as a single C file, but you could try concatenating the files into one. Usually people redistributing source code don't mind having several files bound together by some make|build script. The nim compiler has the --genScript switch to make one. Most people willing to get something redistributable prefer a binary static|dynamic library or final executable.
The fact that there are only 18 questions on StackOverflow could also mean that the language is that good that rarely you find something requiring further explanation. Or maybe Nim users use the Nim forum instead for questions (
http://forum.nim-lang.org), where finding a C forum or Python forum is not that easy/direct.
You copy the nimbase.h file along with the nimcache/*.c files. That's it. The compiler doesn't do it because it's a waste of time/space copying a file which you most likely can include from somewhere else, and it's not a generated file.
Nimrod includes rst parsing and html/tex generation (
http://build.nimrod-lang.org/docs/rstgen.html). While orthogonal to your quest you may want to look into its implementation for inspiration (or adopt rst instead of asciidoc for your publishing needs).
Note that nimrod compiles to C, and your JVM may be implemented in C or C++. So for the measly gain of not having to run a command on the destination platform (nimrod c name.nim) you are bringing in the runtime performance drawbacks of the whole JVM and requiring a further layer of abstraction.
Plus bytecode doesn't mean a program will run at all, look at all the java programs which run on android without modification, oh, wait...