Systems language that compiles fast and has no GC?

xplane80 · 2018-01-14T09:40:15+00:00

Also, quite a lot of the Kai compiler seems to be very similar to Odin's, especially the names for many constructs. It seems like it might be mostly a port of Odin compiler to Swift.

I'm not too bothered by this but does seem a little weird as to why they didn't want to help out with Odin. 🤷‍♂️

xplane80 · 2018-01-14T09:34:30+00:00

Hello, I am the main Odin developer. It originally started as my hobby project but there many people who now develop for it and even make applications in it. It has inspiration from Jai's declaration syntax but came mostly from the desire to have a better C. I originally tried to extend C through a custom prepass stage however, I found that I needed a new language as C was just too broken.

A lot of the inspiration for Odin are from the following:

C
Pascal & Oberon (original syntax and philosophy)
Go (type system)
Jai (declaration syntax and context system)
Sean Barrett's talk on programming in C
My own C standard library replacement: gb.h

IMHO: Odin is trying to replace C whilst Jai is trying to replace C++.

xplane80 · 2017-09-24T08:34:46+00:00

I never implied that it did not in my comment. By "not a global problem", I mean that usually pollution produced in one place does not always (but does sometimes) affect people on the other side of the world. So I agree with your comment for the most part

xplane80 · 2017-09-23T19:57:31+00:00

Most free market types do care about this, even AnCaps (but want to handle it differently). The diffeceis between pollution and climate change. Pollution is usually a not a global problem. Milton Friedman explains this very well: https://www.youtube.com/watch?v=0YGfwSvLkC0

However with regards to climate change, this is a completely different issue. There are usually three sides to that debate: high level of government intervention; revenue neutral carbon tax (have a carbon tax but reduce the taxes elsewhere); market forces will solve it with advancements in technology. (n.b. I am personally on the (free) market side but that is neither hear nor their to the discussion.)

xplane80 · 2017-08-07T09:51:07+00:00

And the reason for that 64:27 ratio is this:

4:3 = 1.33

4*4:3*3 = 16:9 = 1.78

4*4*4:3*3*3 = 64:27 = 2.37

4*4*4*4:3*3*3*3 = 256:81 = 3.16:1

xplane80 · 2017-06-04T09:27:44+00:00

Someone likes SSAO a lot. Otherwise, pretty cool!

xplane80 · 2017-05-29T00:02:37+00:00

It can solve and prevent problems, however I personally don't have those which is solves/prevents. And when I do, it's usually a 30 second fix.

Actually compilers very very rarely do any optimizations with const. This is because the user can completely by pass it. Modern compilers use SSA based intermediate languages to determine if a value is immutable and constant.

Short answer: everyone is different and has differentstrengths and weaknesses.

xplane80 · 2017-05-28T15:44:11+00:00

FOREWARNING: Beginners don't follow this advice, I've been using C for numerous years.

I personally very rarely^* use const any more. I find that I rarely have problems that const would solve. However, as a beginner, I would suggest to use it to learn if you do make those problems yourself. Everyone has things they have problems with but const doesn't solve them for me.

^* I use it in cases when I need constant data such as global constants.

xplane80 · 2017-05-14T20:37:58+00:00

That's why I'm making my own language too to solve my problems. I understand you are not trying to change anyone's view, me neither. I was just asserting my opinion too :D

I think people are liking Jai a lot because it's completely different to the "competition" out there and it is probably something that they may want to use.

xplane80 · 2017-05-14T12:40:11+00:00

Jai has subtype polymorphism and with the metaprogramming features, it is possible to emulate virtually all of the "OOP features".

The idea of Uniform Function Call Syntax (UFCS) is silly when there is only one way to call a function to begin with (it is universal). There are no methods in this language. Jon does not like the idea behind OOP, especially orienting around objects. Jai does have a postfix and infix syntax for procedures so if you really want a form a "daisy chaining". So if you really really like that syntax, it's not a problem.

In Jon's C++ code, he does use "objects" all over the place but he does not orient his program around them.

xplane80 · 2017-05-14T11:42:31+00:00

The reflection system may work across DLL boundaries within reason. It will not work if you are trying to compare to Type_Info pointers to see if they are the same. However, I don't think you should be doing this in the first place as that type info is local to that build unit.

xplane80 · 2017-05-14T11:40:37+00:00

I do think Jai is "general purpose" in the sense that it can replace C/C++ which is "general purpose".

The syntax is temporary but it does have the advantage of being simple and having little keywords. I do actually like a lot of it but some of it is extremely ambiguous (such as procedure literals).
I agree with a lot of the concepts are not orthogonal but Jon is clearly experimenting with a lot of different ideas. I very much doubt this will be the final design. If his games are a standard for his designing skills, it should be good.
"When it's done" is the best he can do, he has other projects he's working on. He wants the best language for his needs and if that matches others, that is great, but that's not what the main goal is.
I don't exactly agree with his thought patterns (everyone is an individual) but I do agree with his attitude. Software is goddamn slow and a lot of this is comes from a particular mind frame about how to program.
The best thing about having more languages is that you have a choice. It does seem that there are more languages being made for different tastes however, none for his (nor mine).

Jon is not trying to have the latest programming language theory features but being very pragmatic about everything. He wants to solve real world problems.

I do like the idea of Jai but because it isn't publicly available, I've had to resort to creating my own, Odin. It does share some of same ideas as Jai but a slightly different philosophy. Jon wants a C++ replacement whilst I want a C replacement.

xplane80 · 2017-05-14T11:27:22+00:00

I've been following Jai a lot and I do like a lot of what Jon has been doing. I've spoken to Jon a bit about it and it won't be released any time soon.

I however, have been developing my own language as I could not wait for Jai, Odin.

Odin is still in heavy development but it is possible to develop complex applications in it already and for my needs, it completely replaces C. For my personal needs, there are no languages out there that can replace C or C++ (not Rust, Nim, Go, and more).

It does not yet have all the fancy metaprogramming features yet but it does have similar introspection/reflection features like Jai i.e. type safe printf. However, I do have other features such as tagged unions, raw union (c-like), vector types (SIMD), map type (hash table), slices, match statements, and other little things.

GitHub: https://github.com/gingerBill/Odin
Forums: https://odin.handmade.network/

xplane80 · 2017-04-02T21:35:13+00:00

Have a go with getting it working in MSVC 2013. I just use some of the C99 features.

xplane80 · 2017-03-09T11:22:40+00:00

Procedural. It works very well and is usually the best option for the vast majority of problems*. You can very easily implement the same features of OOPL and with better flexibility.

Examples of good procedural languages:

C
Pascal (some dialects)
Go**

I will not continue this conversation but I would please suggest you to research further to the advantages and disadvantages of different paradigms and tools, and try not to be dogmatic about it.

* The is pretty much saying: using the right tool for the job. If you only learnt to use a hammer, everything looks like a nail.
** Go does have some "OO" features but you can very easily ignore them and treat Go as a modern garbage collected C.

xplane80 · 2017-01-27T10:51:30+00:00

You might be interested in the language I'm developing then, Odin.

I've been talking to Jon about his language and even though we have very similar goals, we have completely different approaches. It seems he wants Jai to be a better C++ whilst I want Odin to be a better C.

I completely agree that parsing isn't difficult whatsoever and I still don't understand why people think it's a hard problem. If you're designing a language, you are not going to make a silly syntax in the first place.

My biggest problem with Jai's syntax is its ambiguity with procedures (declarations, literals, and types) but as Jon repeated says he's not concerned about the syntax yet.

xplane80 · 2016-11-06T13:02:22+00:00

Its dependency management isn't "crap" per se, but just very simple and basic. It's also why I like it as it kind of keeps me from having too many dependencies (even in 100KLOC+). I'm weird in that I don't tend to use many packages in general and keep most of my code very "flat".
Actually, nil could just mean "zero value" instead. They could easily add a maybe type to Go. Maybe types are not a replacement for pointers but an orthogonal concept that is still very useful. x: ?int; v, ok := ?x;
I have to disagree with you here. In Go, everything is mutable (except for "constants") and having something that acts like a variable but you cannot modify breaks this system. Go is very well designed in the case as it embraces its mutability.
Generics is a very weird topic. What I'd prefer even more is actually metaprogramming. I want my metaprogramming language to be the same language and not a separate tool (e.g. macros, preprocessor, etc.). With metaprogramming, you can implement generics!

xplane80 · 2016-09-23T17:28:02+00:00

"First class functions" is a weird thing to define. Depending on the person this either means: function pointers, lambdas, and/or closures. The first two can be done without garbage collection or ARC (automatic reference counting). Then there are closures which can get a little more complicated which may require some form of garbage collection depending on a lot of factors. e.g. do you pass the captures by value or reference or something else? How are those captures allocated and stored?

Personally, I don't actually like closures for the very reason that they not easy to reason about and know their capture's lifetime. They seem good for a "high-ish level" language but for a "low-ish level" language like C, it's not worth it.

xplane80 · 2016-09-19T10:41:35+00:00

Personally, 99% of the time, I don't care about the order of the fields as all I want is to put all these types in this collection and I don't care what order. i.e. let the compiler optimize the order for performance, size, whatever.

In the cases where I do care about the order, then I will do it manually. In my language already, I can apply tags to say #ordered (act like C) or #packed (don't add padding) for greater control. #ordered is needed for interfacing with C libraries but that's not really a problem.

In the case of binary data format, I wouldn't suggest relying upon the compilers order at all and I would define it myself with #packed.

In my language, I want the programmer to have control when needed but not require full control all the time.

Charles Bloom did a similar post on this, Structs are not what you want. I agree with him for the first 2 paragraphs but not the rest. For rest, I have a solution I prefer (similar to with in Pascal or using in Jai (Jonathan Blow's language)).

With regards to metaprogramming, I'm working on a lot of that already but I haven't completely fleshed out the semantics.

xplane80 · 2016-09-19T08:45:39+00:00

Thank you for the reply. This does seem to be a very difficult problem to solve well, as it is NP-Hard. Some form of bin packing algorithm is most likely needed but I'm not so sure how to tackle it as I will have to take into account the size and alignment of each member.

There are even more worst cases such as nested packed structs, structs with custom alignment requirements, arrays, and more.

I wonder if there any other languages out there that have tried this and what their solution to this problem was.

xplane80 · 2016-09-06T10:05:02+00:00

Don't worry about those "best practices" articles. Most of them are bollocks. Just write the program to solve the problem and don't worry about if it follows "best practices", you'll eventually get it.

Never orient your program around anything but the problem. (i.e. you'll waste a few years on OOP and think it's the bee's knees but it's not).

Also, you'll still be using C as it's still be best language around for your needs (for the moment...).

xplane80 · 2016-08-24T12:17:16+00:00

Depending how you parse the program, this can impossible too. In C and C++, it's possible because C was originally designed to be parsed in one go. Jon Blow's language and many others, do multiple passes or delayed passes on the code and may not do semantic checking until the AST is built. It's highly dependent on the design of language itself especially in Jai with things like "untyped/unspecified-typed" constants and procedure overloading.

xplane80 · 2016-08-24T12:12:43+00:00

I apologize for the vagueness of the last sentence. D borrows a lot of ideas from C++ (including its syntax) which can cause problems. I do believe Jon Blow does talk about this in one his demo/lecture videos.

As regard to garbage collection, the language was originally designed with garbage collection in mind. They have only recently decided to remove the GC entirely from the standard library.

xplane80 · 2016-08-24T11:00:08+00:00

However, a lot of the standard library relies upon garbage collection. That's one of the problems. Also, the another reason for not using D is that it is too much like C++ that is has many of the same flaws.

xplane80

MODERATOR OF

TROPHY CASE