HNHacker News
TopNewBestAskShowJobs

greggirwin

164 karma · joined May 23, 2015

submissionscomments
greggirwin··on We Made Amiga, They Fucked It Up (2015)
Yes.
greggirwin··on The Red Language
I'm part of Team Red, though I only speak for myself here.

TL;DR -- Tools and infrastructure

It's true that people don't pay for languages, but did they ever? Mostly, people have paid for tools. Tools that help them solve problems. In the early days, nobody paid for any software. Then there was a period where MS, Borland, Zortech, and others sold boxed compilers for C/C++, Pascal, Basic, and even Prolog (Borland Turbo Prolog, yep). Later Visual Basic and a raft of RAD tools, many of which had languages in them. And Hypercard had its day.

Now you don't pay for languages, very clearly, but did you ever, really? Yes, in smaller numbers. For example, people paid for MSBASIC/PDS, QuickBasic, TrueBASIC, GFABasic, XBasic, PowerBasic, or Visual Basic, because each had features they needed. But they didn't need, or pay for BASIC. They paid because the tool was effective and fit their needs.

Red is not just an exercise, but building a language is hard, slow, deliberate work, especially when you do it from the ground up. That's why other langs don't do it that way. They compile to another language, now often transpiling, to leverage the existing infrastructure. This can be a big win, but you also get all the baggage of the old system, which is a cost.

Did JetBrains create Kotlin, hoping to cash in on the language itself? I don't have inside info, but I don't think so. Smart people they are. They sell tools, and being able to provide the first and best tool(s) for a new lang is a huge opportunity. Not to mention having all the experts in the language, for consulting and contract work day one. Everybody else has to play catch-up.

Do you see where I'm headed?

Those are just a couple ways you can be a commercial success by building a language. And that's a necessity. To win, we have to survive.

But that's not what motivates our programmer hearts. Fighting software complexity, showing people there's a better way, making the world a better place by improving how software is built, at all levels; that is what drives us. Software development, if not broken, is at least very, very bent.

Why are there so many Low Code tools out there? Is mobile dev as easy as it could be? Are we there yet? How far have we progressed, in how software is built, since 1970? Do you have all the tools you wish you had in your language of choice? Why not? Why does it take 7 languages and 20 supporting tools and frameworks, all with different syntax, models, and runtime needs to build a simple web app today? Why does "Javascript Fatigue" exist as a term? Is containerization a solution, or simply a band-aid over cancer? Left-pad anyone?

You ask "Where's the market?" Well, it's everywhere, and Red can do everything (or will, before too long ;^). So we have to narrow it down. We hate doing that for the language, because it gives people a keyhole view of what Red can do. That's where specific products and tools come in. They, like dialects are to the base language, have a sharp focus.

There are massive opportunities to be had. And not just by us. Does Brendan Eich get JS royalties? Does Douglas Crockford get JSON kickbacks? Did they change the world, and have a lot of people made a lot of money because those technologies exist? You bet they have. But think even bigger, if you can, because what if you could be compensated for creating great tech that others leverage? And if you think Red won't win because it's Lisp+Forth+Logo, has free ranging evaluation, or other things a dev can pick syntax nits about, that's fine too. JS has flaws, but look at all the dialects that transpile to it. Those are just DSLs, if you think about it, constrained versions. And what is Red better at than any other language?

Thanks for listening.

greggirwin··on Living without the modern browser
The question is what "browser" means. If viewing data connected by hyperlinks is the goal, that's pretty easy. Rebol's approach to X-Net (Executable Internet) apps is very different, with the goal of being a way to share both data and active content. You can do both, the web we know just wasn't designed for that.
greggirwin··on Ask HN: What metaprogrammable language do you/would like to use?
I use Red (full disclosure, I'm on the team), and have used Rebol (Red's direct ancestor) since 2001. When I find something that works, I stick with it, though I also keep an eye out for new things.

Red's heritage comes from Lisp, Forth, and Logo. It's homoiconic and metacircular (it is its own meta language). Where Rebol was strictly interpreted, Red can also be compiled, and has hygienic macros. But you don't really need them. They're nice for moving things to compile time, but Red puts a twist on Lisp's sexpr model that obviates the "need" for them in most cases. Technically, you can say Red uses an fexpr model, but a more human-friendly way to say it is that "Everything is data until it is evaluated.", and you have a lot of control over when evaluation occurs.

For interop, Red has a system-level dialect called Red/System. It's a C level language and is a dialect of Red. That is, Red is high level and is used to define the Red/System dialect, which is used to implement Red. It's the circle of life. :^) You can also compile Red as a library and call into it via an API, so you can use it as an embedded language, or doing things like the Excel example in this blog entry about Red's macros: https://www.red-lang.org/2017/03/062-libred-and-macros.html which also mentions one of the easiest ways to preprocess input, with the `system/lexer/pre-load` feature.

ASTs are mentioned in a few comments, so I should add that while you can certainly do that with Red, it's another thing that can often be avoided entirely. With other langs and tools, you almost have to take that approach, to make it manageable. With Red, there is a function called `parse` which consumes input and supports BNF-like rules to process it. `Parse` is a Red dialect, and the rules are just data it interprets. Rather than building ASTs (though there are some cool examples, and tree-rewriting systems out there), just interpret the input directly.

If it sounds like I'm against metaprogramming, while being on a team creating a language that supports it deeply, that's not the case. Metaprogramming is a great tool for thinking, but it can also make things much harder to debug and maintain. For real work, use what makes your intent clear, and avoids as much complexity as possible.

greggirwin··on Ask HN: Where are the GUI libraries that aren't bloated?
A message box is not the same as a dialog with user controls.
greggirwin··on Ask HN: Where are the GUI libraries that aren't bloated?
Be sure to go to the 7-GUIs web site to link to other code examples. They aren't all in the main repo anymore it seems.
greggirwin··on Ask HN: Where are the GUI libraries that aren't bloated?
Red and Rebol already came up, which is what I answered with, to a question on Quora a couple years ago:

https://www.quora.com/Why-is-using-a-GUI-in-most-of-all-prog...

In that answer I link to the 7 GUIs project from Eugen Kiss: https://github.com/eugenkiss/7guis which I think tried to answer your question from an evaluative, example-based approach. What I like about it was that it kept the requirements simple, but moved beyond Hello World, so it's a bit more fair to systems that have a higher lower bound for minimal GUIs.

For the last part of your question, think in terms of generality vs a DSL-based approach. A GUI system that is completely general, and can't make any assumptions, is naturally going to require more information for a given output. Once you narrow down the possibilities, and include defaults and the ability to configure things for re-use (e.g. widget styles and themes), you can dramatically reduce the effort needed. Constraint based systems (e.g. Cassowary) are another way to go.

greggirwin··on Ask HN: What does your development stack look like in your favorite language?
Most responses so far support your view that it's difficult to get up and running. So many pieces and parts, which doesn't just mean getting an MVDE up and running, but learning and using all those tools, libraries, polyglot-based environs, and domains they each inhabit. The fact that you asked this question is telling.

As far as choices and diversity, how different are things, and how have they changed from what we had 25 years ago? That sets the context for my answer.

My language of choice is Red, a direct descendant of Rebol. You've likely never heard of either. And Red is still Alpha software. That doesn't mean we don't do real work though. In the spirit of full disclosure, I am part of Team Red, so I'm biased. :^) One of our taglines is "Fighting Software Complexity", which is what makes software development so painful today. The sad part is that it's not necessary (at least in most cases). I'll try not to evangelize, because anyone using any tool or language to fight software complexity is on the right track in my book.

Reducers (what we call Red Users) have widely varying setups, as Red is cross platform, with syntax configs for a number of editors and VSCode plugin. Any editor will do.

I like the short responses a couple gave: `PyCharm` and `Go+Plan9Port`. Simpler is better. Red falls into that category, as you just need to download a single 1MB EXE, which contains the entire toolchain. It will self-build GUI and CLI REPLs from that. Cross-compiling and a cross-platform GUI system are built in as well, not separate. No dependency on GCC, CLANG, JVM, or others (though we may add an LLVM back end, and compiling service to use it, this year).

We'd like to be even smaller than 1MB, but want to include useful features too, so it's a balancing act. We also give up features others get for "free" by resisting external dependencies. This comes back to avoiding difficulties. You can compile Red apps that have no external dependencies themselves, and will be ~1MB (I won't go into Red/System here, but it's like C in EXE size and speed). This is important if you consider deployment as part of real work. How do you deploy your apps? In the case of Red desktop apps, you just give the user an EXE.

That's about as non-evangelistic as I can get it seems. :^) This isn't meant as an ad for Red, but to provoke more thought about our entire ecosystem mindset. We can have recipes for swaths of tools and libraries, but how big is the entire dev/deploy/runtime system, how many places can things go wrong, and how much do you need to know to keep it all working?

Good question. Thanks for asking it.

greggirwin··on Red Programming Language: Plans for 2019
As has been noted by others, we have never "had a go" at Clojure. Language designers and the people who build them have our respect, even if our choices differ. If we criticize them (and we do at times, being human, and thinking we're right ;^), we try to be fair. Rich Hickey's talks are some of my favorite to watch, and I have nothing but respect and admiration for him.

Of course everything has a cost, but to call us megalomaniacs is a bit harsh.

You didn't say you understood the reason, but I pointed it out in another reply here. By bootstrapping from Rebol, and being 95% Rebol compatible, we proved that Red could self host, and also leverage almost all the existing code when we get to that point.

To ask if we understand those issues comes across as insulting. Sure, we could be tech smart but miss obvious things, but that one we know about. ;^)

greggirwin··on Red Programming Language: Plans for 2019
@hjek, as @dockimbel noted, and we have never concealed, Red was bootstrapped using Rebol. Doc's stats break things down pretty well, but there's another point to be made. Red is ~95% Rebol compatible. This is a very important detail, and proved that Red could be used to self host in the future. When the need to self-host becomes important, it can be done relatively easily, and with confidence.

Is that a fair and accurate assessment?

greggirwin··on Red Programming Language: Plans for 2019
Dimitri, you've obviously looked into Red in some depth, which is appreciated. And your comments and criticisms have been heard. It's easy for miscommunication to occur in chat like this, so we can probably close this particular thread of conversation, as I don't think it's productive anymore. As much as I now want to chime in to defend our position, it wouldn't help. You make valid points, but comparisons with other projects are hard.

If you don't like Red, or how the project is being managed or progressing, that's fine. Sharing what you've learned is also great, as long as others can form their own opinions from facts presented (again, hard to present deep info in chat). All we ask is that you try to be fair, and think about how harmful negative press can be to a project. When you've put a huge amount of time and effort into something you believe in deeply, it's easy to get defensive when someone criticizes it (in ways that may seem unfair).

How things are said is important, as well as balancing pros and cons. In re-reading the chat, I admit that I got defensive, which is why I didn't respond initially.

In conclusion, can we do better? Yes, of course. Is much of the code written by a very small core, who knows the system well, and isn't writing it with the expectation that others will read and learn from it? Yes. Can we do better on testing? Yes. Do we already have more than 30'000 tests? Yes. Are those core devs pretty darned amazing, considering what they've built (insert feature list here :^)? You bet they are.

Red isn't for everyone. Our approach won't be to everyone's liking. But we hope people will be fair, wish us luck, and maybe even applaud us for trying to build something that will make their lives better. At the very least, we hope they won't talk us down unfairly.

greggirwin··on Red Programming Language: Plans for 2019
Understood, so you know there was a reason for branching out into the blockchain space, as there's a real need for better langs there, and less competition, which leads to more visibility in an area that his hot technology. For the project to survive, we'll have to try a lot of things.
greggirwin··on Red Programming Language: Plans for 2019
But that was a very important choice. Do you understand why?
greggirwin··on Red Programming Language: Plans for 2019
A noted, it's easy to start, but also powerful. Logo was the same. It was most well known for the turtle, but it was really Lisp, and Brian Harvey (Berkeley CS Prof) wrote a great 3-volume series called Computer Science Logo Style.

Red is potent, but also Alpha.

Big libraries are rarely needed. e.g., we have a native image datatype, and codecs for 4 common image formats. No external libs needed. The GUI system is built in, though it added to our size quite a bit. We're over 1MB now.

greggirwin··on Red Programming Language: Plans for 2019
There are a lot of topics here now, which is great, and the opening question about what to make of Red is a good one. The problem in answering it is the same problem we have when pitching it to people: it's hard to sum up.

Is there a catch? Yes. More than one actually. One is that, because we are building things from the ground up, we don't get things for free that other languages do. For example, JVM-based langs get a lot for free, but at a cost. Another catch, and a big one, is that Red is fundamentally different in some design aspects, both superficial (syntax) and deep (all is data, words and bindings, etc.). Those two things deter a lot of people. We get that. If you want to keep doing things mostly the way you always have, Red is not for you. If you just want lots of familiar libs and features, you may have to wait for them, or help build them. This makes us a self-selecting community. We don't want to be a cult, but we also won't compromise certain things with the hope of it making us more popular. There are few easy choices here.

For those who find Red, and give it a shot, not all will like it, and not all who like it will understand it or use it effectively. We also accept that. For those who have the courage to try something new (I mean, really try it), and who take the time to understand it (the process of which brings its own benefits, no matter what language you use), and who reach the moment where it clicks in their head, there is no going back.

Whether you support and commend features, or criticize them fairly, they are features. To have meaningful discourse about Red, we need to go deeper. Much deeper. If you only want to compare Red to other tools, on their terms, we'll often lose. But if you look at what Red can do, that they can't, and Red's fundamental goals, it becomes clear that comparisons don't mean much. That's true for any 2 languages. It can help, provide context, etc., but ultimately you have to evaluate a language or tool on its own merits, just as you have to evaluate yourself and see your own worth and value without comparison to others.

If you think the state of software development is just fine, and a few tweaks are all we need, Red probably isn't for you. But if you have nagging doubts about why things are so hard, so big, so complex, when it seems like they should be easy, small, and simple...maybe you'll be curious and brave enough to take the Red pill. Most, we know, just want the big juicy steak.

We can talk more, explain more, if people want. Gitter is our most active channel, but we can try to respond here as well. We're glad to hear what people like, and accept fair criticism.

greggirwin··on Red Programming Language: Plans for 2019
Good feedback. Thanks.
greggirwin··on Red Programming Language: Plans for 2019
We do try to maintain a high standard of civility.
greggirwin··on Red Programming Language: Plans for 2019
This came up not long ago, and we have to define "cross platform" to say whether Red meets the criteria. Red does have a cross platform GUI system, though it is only fully implemented on MacOS and Windows currently. We don't run on iOS at all yet. What the current system shows is that a single, cross platform dialect can abstract away the native OS APIs in a clean way, though there will always be tradeoffs, as every OS has different features.

The RED Wallet is an example of a cross platform app, done today.

greggirwin··on Red Programming Language: Plans for 2019
Creating a dialect is pretty easy, though it's a broad term, so not ALL are easy to create. :^) An environment is an entirely different beast, but @9214 addressed that already as well. The more you leverage core features, the more you get outside your dialect though. You trade power for safety. It's easy to create a simple Logo Turtle interpreter though.
greggirwin··on Red Programming Language: Plans for 2019
If you read the old blog entries about why it was done, do you still feel that way?
greggirwin··on Red Programming Language: Plans for 2019
Development is far from haphazard, but we're always open to examples of how other projects we can learn from, as long as it's a fair comparison and the resource and organization aspects align enough that we can leverage things we learn.
greggirwin··on Sneak peek at Red on Android
> I would have expected recent news to tie into the ICO promises

Please read the blog entry again. It specifically says:

> Those features were implemented in about a month and half in August/September 2017. We have delayed the continuation of that work, as we need to focus our resources on higher priority tasks for now, like Red/C3 and full I/O support.

If you also read https://www.red-lang.org/2018/03/roadmap-updates.html, it should clarify exactly where we are and where we're headed.

greggirwin··on Sneak peek at Red on Android
https://www.red-lang.org/2018/01/red-here-we-go.html shows the complete breakdown of token distribution, and is where the data is pulled from in the above script demo.

In a very real sense, we can't think of "money raised" in terms of a country's legal tender (what cryptos call 'fiat currency'). Remember, cryptocurrencies have no jurisdiction. You can see how much ETH was raised, but what that really tells you, we hope, is how much investment interest there was, based on the technology backing the project.

greggirwin··on Mark – A simple and unified notation for both object and markup data
Cool. I'll check those out.
greggirwin··on Mark – A simple and unified notation for both object and markup data
Henry, did you use Gunther Rademacher's RR diagram generator?

Best of luck with {mark}.

greggirwin··on The Next 700 Programming Languages (1965) [pdf]
Or languages whose strength is in building other languages.
greggirwin··on Red Language: Answers to community questions
Yes indeed. He's a great guy.
greggirwin··on Red Language: Answers to community questions
I've made a living using Rebol for 16 years, with other things when I have to. :^)
greggirwin··on Red Language: Answers to community questions
Cross platform for Windows and Mac are there today. "Red" does make searches tough, we know. Red currently has backers, and Linux GUI hasn't been on their priority list. Android will come before Linux, and is far along already. For Linux, today, Wine is the suggested approach.
greggirwin··on Red Language: Answers to community questions
From what has been said publicly, the blockchain sub-project will help raise funds to fuel development in the near term. Long term sustainability, and value, will come from building products, services, and tools.
← PreviousPage 2 of 5Next →