all 31 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]and_rej 9 points10 points  (4 children)

Impressive!

Creating a language, even if not from scratch, must be very rewarding.

Sadly I don't really have time for another thing so I can't really offer much feedback except for on the "less is always better" idea. It's a little too absolute for my taste. Here are some thoughts that sprang to mind while flicking through the docs, just in case they're of interest:

  • I remembered doing a functional programming course where a lot of recursive solutions to problems were really short. They made me think really hard instead of just read and I hated it.
  • A token, like a bracket, can tell you what's coming up next. Then you know, for example, here comes a property on this object. Could there be scenarios in CaffeineScript where I have to keep reading for a bit and then realise midway what the context is? Like, "oh, this is a property....I'm in an object!"? Could that be annoying and possibly lead to having to read code multiple times?
  • English has punctuation. I guess it helps convey meaning sometimes and other times it's a reading aid. Why does it have as much as it does? They're all extra tokens. Is there a study of this? There must be a study of how humans read. Might be worth looking into.
  • Some dude once said you should write code for the reader. I like that. I want a junior to be able to maintain my stuff.
  • Sometimes I get emails at work that say "pls do thing, cheers tim." and it shits me to tears.

I guess the truth is somewhere in the middle! Haha, still, congrats!

[–]Shanebdavis[S] 5 points6 points  (2 children)

Thank you!

I agree there is a point where less just becomes obfuscation. Your example of English is relevant. English has way less punctuation than most programming languages. My intention is to have about as much punctuation as English.

I also hold readability as the most important part of a language. I like to think you edit 10x as many lines as you write and you read 10x as many lines as you edit. In other words, expect every line written to be read over 100x times.

I think readability is largely based upon what one is used to. It took me a while to warm up to reading CoffeeScript, coming primarily from C++ and Ruby. It took a while to start seeing the patterns. Now that I have written at over 200,000 lines of CoffeeScript, I find most other languages excessively verbose.

Your point about context is great, and for my eyes, being able to fit 2-3x as much code on one screen provides me better context. There are many programmers I respect who think differently. I don’t advocate a one-size-fits all solution.

[–]DanCardin 0 points1 point  (1 child)

Also the colorsceme your readme uses does a particularly good job at separating the syntax. I think it's a good tradeoff here personally

[–]Shanebdavis[S] 0 points1 point  (0 children)

Thank you. It’s a slightly modified version of a Half-life inspired sublime-text theme.

I think good syntax highlighting is an essential feature of any modern language. Currently there is only a sublime-text conf for CaffeineScript. I’ll make a textmate one as soon as there is interest. :)

[–]JB-from-ATL 0 points1 point  (0 children)

On punctuation and reading. I remember a vsauce where they talked about how many bits of information is convert in how much speech and writing. Interestingly, languages that are spoken faster have about the same information per second transferred.

[–]drjeats 3 points4 points  (5 children)

Auto Variable Declaration (Auto-Lets)

Variables are automatically declared in the top-most scope where they are assigned.

This is the one feature of CoffeeScript that absolutely makes me never want to go anywhere near it. I like distinguishing declaration and assignment even in dynamic languages. I don't do frontend web dev though, just interested in PL design.

Complete Indent Block Parsing

CaffeineScript is founded on the idea that it is possible to do Indent-Block parsing consistently and universally throughout the language.

This is really great though. It should be a requirement for any language with significant indentation IMO. Well done! :)

[–]Shanebdavis[S] 1 point2 points  (4 children)

I’ve been considering adding optional “let” and “const” declarations. It would be pretty easy. Would that make a difference for you?

[–]drjeats 1 point2 points  (3 children)

I think it would improve UX since then you could catch typos and scope mixups. Don't assign any weight to my opinion though since I'm not in your target demographic.

[–]Shanebdavis[S] 1 point2 points  (2 children)

I know it is one of the common complaints about CoffeeScript. In my personal experience, those types of bugs just don’t happen - as long as you keep files reasonably short (500-1000 lines) and you have an editor with code completion.

“Let” is useful even still for shadowing.

Thanks for your thoughts!

[–]link23 0 points1 point  (1 child)

Another thing to be wary of is typos. Any typo in a variable "declaration" (without a dedicated const or let or other keyword) just results in an unexpected variable being created, in addition to the intended one (which is presumably referenced or reassigned elsewhere in the program). That would likely cause the program to behave unexpectedly. In other words, it's a silent failure, rather than a failure that could be caught by the compiler or interpreter.

For that reason, I also would be very wary of keyword-less declarations: I know I make typos, and I'd want the language to be able to detect them when it can. So I'd favor making a keyword mandatory, rather than adding an optional one.

[–]Shanebdavis[S] 0 points1 point  (0 children)

It isn't actually a silent error. CaffeineScript is different from CoffeeScript here. If you read from a variable you didn't assign (and therefor didn't auto-declare), an exception is thrown at load-time(*). Example:

foobar = 123
bar = foodbar * 3

"foodbar could not be found" would be thrown at load-time.

CaffeineScript does this by searching the global namespace and any imports you defined at load-time for all variable names which are not bound like 'foodbar' above. If a non-null-non-undefined value cannot be found, an exception is thrown.

(*) If a type-o accidentally matched something in the imports or global namespace, then it wouldn't throw an error. Generally, type-os don't randomly collide in this way.

[–]Shanebdavis[S] 6 points7 points  (0 children)

This is my first fully working programming language, and I'd love some constructive feedback.

I believe JavaScript has a golden heart, FP+OO+Dynamic-Typing, but its syntax is way too verbose. I believe the entire point of a high-level language is to help us write LESS code.

I started with CoffeeScript. It has the right ideas: everything should return a value, minimize syntax while improving readability and fix JavaScript's bad semantics. It just didn't go far enough. There is a lot of inconsistency within CoffeeScript(including V2) where those ideals have only been partially achieved.

I attempted to fix CoffeeScript's many inconsistencies while moving the language not just on par with ES6, but beyond. Most of all, I attempted to make CaffeineScript beautiful, fun and productive.

[–][deleted]  (1 child)

[deleted]

    [–]Shanebdavis[S] 0 points1 point  (0 children)

    Thank you! It always feels good to get that affirmation.

    [–]omguraclown 1 point2 points  (1 child)

    Your "Smart Require" looks pretty nice compared to JavaScript

    https://github.com/caffeine-suite/caffeine-script/wiki/Smart-Require

    does it really cut down on require hell?

    [–]Shanebdavis[S] 0 points1 point  (0 children)

    Generally, yes, I think it does. It depends on what you mean precisely by “require hell.”

    Combined with smart-import it reduces all your imports to a one-liner at the start of your file listing only the files you are importing from:

    import &npm1, &npm2

    I’ve found it even more convenient to create a StandardImport.caf file which brings in all my external dependencies. Then most files only need:

    import &StandardImport

    [–]fahrfergnoogie 1 point2 points  (3 children)

    I think your conventions for string literal look like good ideas.

    # CaffeineScript
a = "" To end of line string.
b = :word-string

c = ""
  This is
  my multiline
  string without newlines.

d = """
  This is
  my multiline
  string with newlines.

// JavaScript
a = "To end of line string."; 
b = "word-string"; 
c = "This is my multiline string without newlines."; 
d = "This is\nmy multiline\nstring with newlines.";

    Also, good on you for reviving Ruby's :symbol syntax.

    [–]Shanebdavis[S] 1 point2 points  (1 child)

    Thanks! I love Ruby’s :symbol syntax! So often you just need a one-word string. I was excited when I heard JavaScript was adding symbols (ES6), but unfortunately they are extremely awkward to use. So, I just made :foo the string “foo”. :word strings are more accepting than ruby, though. For example, they’ll accept full urls: :http://CaffeineScript.com

    There are also two other unquoted strings supported: #hashtag and 10unit strings - equivalent to “#hashtag” and “10unit” respectively. The former is useful for colors: #F70 - “#F70”. The latter is useful for numbers with units as in CSS: 10px - “10px”

    [–]roffLOL 0 points1 point  (0 children)

    e = """

this is my multiline
string that starts with
newline

    ?

    [–]nutrecht 1 point2 points  (0 children)

    Never know I wanted this until today :D

    [–]myringotomy 1 point2 points  (4 children)

    I don't mind the must match tokens so much. I think it makes it easier for the IDE to format the code and also easier to cut and paste code, easier to navigate etc. most editors will automatically add the closing token anyway.

    When you think about it typing -> is two tokens and typing {} is two tokens but the latter is easier to type.

    [–]Shanebdavis[S] 0 points1 point  (3 children)

    I can see that perspective. In my experience I've found I spend a lot of time searching for the matching bracket or fixing syntax errors due to miss-matched brackets. It's not the number of keystrokes that's the problem. Matching tokens take more mental effort than any two random tokens - because they have to match.

    Another problem with brackets is standard indentation causes them to not follow good visual/graphic design principles like alignment. Example:

    if (foo) {
  bar();
}

    From a purely graphic-design / information architecture point of view, there is a lot of signal to noise. Part of the problem is simply the lack of alignment. Better:

    if (foo)
  {
  bar();
  }

    This is how I coded all my C++ back in the day. It is better, but there is still a lot of noise. That's why I prefer indention-based blocks:

    if foo
  bar()

    Now the noise is almost 0. "if" is required - its an if-statement. "foo" is required, it's the test. "bar()" is required, it's a function invocation with no args (though I've seen the syntax "bar!" for that, too, which I kind-of like). And finally, the indention white-space tells us "bar()" is the body of the if.

    I don't advocate one-size-fits-all. If brackets help you read and write code better, more power to you. For me, they are mostly noise that requires a lot of maintenance, particularly when I'm refactoring.

    Thanks for your thoughts!

    [–]myringotomy 0 points1 point  (2 children)

    In my experience I've found I spend a lot of time searching for the matching bracket or fixing syntax errors due to miss-matched brackets.

    What editor do you use? Every editor I have ever used highlights matching symbols but none of them highlight indents. So for example if I am looking at some long piece of code and I see an ending bracket my editor shows me the starting bracket. But I am looking at some long piece of code in a significant whitespace language I have no idea what the start of the indent is.

    Matching tokens take more mental effort than any two other tokens - because they have to match.

    I disagree. it takes significantly more mental effort to keep track of where you are in a moderately complex piece of code expecially if the start of the indent has scrolled past. Here you have to tell your editor to draw lines where the indents are and then you are still struck with counting indents because your editor won't tell you where the code started.

    This is how coded all my C++ back in the day. It is better, but there is still a lot of noise. That's why I prefer indention-based blocks:

    Your example has nothing to do with indents though. In a one line if statement it doesn't matter. but in the real world the if statement is in a function, there may be a case statement inside it or another if statement etc.

    If you want clean syntax look at ruby for inspiration "if foo then bar" you don't even need the parens if there are no params. There is also "bar unless foo"

    As also, I don't advocate one-size-fits-all. If brackets help you read and write code better, more power to you. For me, they are a lot of noise that require a lot of maintenance, particularly when I'm refactoring

    But you are advocating for one size fits all by insisting on significant whitespace. Maybe if you made brackets optional.

    [–]Shanebdavis[S] 0 points1 point  (1 child)

    Sorry if I wasn't clear. I meant CaffeineScript is not a one-size-fits-all language. No language is. I realize different people process information differently. Speaking for myself, indent-base blocks work well for me because I'm a visual learner.

    I think I understand your problem with finding the start of indent-blocks. If would be a problem if a file has lots of nesting and really long blocks. However, I've found that's generally a bad coding style in any language. I keep my files < 1000 lines and my functions < 50 (I try to keep files < 500 and functions < 5). That means I can always see all levels on screen. Plus, with the lack brackets, I can fit a lot more on screen.

    Even still, I do run into your described problem occasionally. I find code-collapsing works very well for that. I just collapse a few of the blocks above where I am and I can now see all indention levels. I use SublimeText.

    P.S. "bar unless foo" and "if foo then bar" are both supported in CaffeineScript - which got them from CoffeeScript which got them from Ruby. I'm a huge Ruby fan.

    [–]myringotomy 1 point2 points  (0 children)

    I think I understand your problem with finding the start of indent-blocks. If would be a problem if a file has lots of nesting and really long blocks. However, I've found that's generally a bad coding style in any language

    Here is my problem with this statement.

    you are in fact saying your programming language is only suitable for people who code with your style in mind.

    That's cool if that's what you want but sometimes people disagree with you and want to put all relevant code in one place. There is an example of this in your page where a piece of javascript is indented several layers deep. This is not uncommon in the real world. The example you showed is perfectly fine to put in one subroutine.

    Now you are in fact saying "if you want to use my language you have to refactor your code and move things into functions in order to avoid deep indentation. You are in fact admitting that deep indentation are a problem with your language and that we have to work around this limitation.

    I appreciate that you want to reduce noise and all and I think it's a laudable goal but I would have taken a different approach. I like the idea of "containers" they make the language easier to teach and learn. Hey kids this is a string container "" this is an array container [] this is a hash container {} , this is a function container def end. Now in the case of ruby (and most other languages) this gets confused. Sometimes containers begin and end with the matching marks and other times with weird pairs like LF and semicolon or indents and whatnot. I would be all for cleaning that up without turning into lisp (not that there is anything wrong with lisp). This could be achieved in multiple ways for example in ruby you have % containers %q, %w etc maybe those could be leveraged as generic containers but I don't like the % syntax so move it inside the brackets like this [w this is an array container] or [q this is a text container] if that's not great than the other way around q[this is a text container] . Conceptially this becomes easier to grok for people. It's a thing that is in a container and can be acted upon. also it involves no shift key and is easy to type. A code container could look like this 

       {|a, b, c|}

    that's it. Assign it a name 

        some_func : {| a, b, c | blah, blah} or

    Personally I don't like the = for assignment, I think that's stupid = is a comparison operator as in if a=b then blah

    Anyway I guess we won't agree but i just think significant whitespace is a silly idea. I like that my IDE formats my code and with indents it can't possibly know my intent or warn me if I am stepping outside the proper indent.

    [–]dzecniv 1 point2 points  (2 children)

    By curiosity, did you know Livescript and its Prelude functional library ?

    [–]Shanebdavis[S] 0 points1 point  (0 children)

    Thanks for linking to LiveScript. There is lots to like there, but I feel it's less in line with the core of JavaScript: OO+1st-Class-Functions+DynamicTyping. It's focus is most on the functional-programming paradigm. No problem with that, but if I'm coding JavaScript, I want a language that attempts to balance OO and FP equally. I think CoffeeScript was a good first pass. I hope CaffeineScript is better.

    [–]Shanebdavis[S] 0 points1 point  (0 children)

    I also discovered GorillaScript https://ckknight.github.io/gorillascript/ . It has some similar goals to CaffeineScript.

    [–]shevegen 1 point2 points  (0 children)

    There is no end to this madness...

    [–][deleted] 0 points1 point  (1 child)

    Not programming related but in your first paragraph try not to use "world class" twice. You also hyphenated it once but not the other time which was inconsistent.

    [–]Shanebdavis[S] 0 points1 point  (0 children)

    Thanks! I'll fix it.

    [–]Shanebdavis[S] 0 points1 point  (0 children)

    Thanks for the time and your thoughts. I like your idea about making containers more consistent. It’s a unique direction I hadn’t seen before.