I've rifled through many a programming font, bought Pragmata Pro at one point (as you can see I also like taller fonts), tried many others over the years (Monoid was my previous favorite ligatured font). Iosevka is my current favorite. My customization args are part of my dotfiles repo so I can install it exactly how I like on any new system without effort.
This section seems to be a direct accusation of attempted obstruction of justice, even though it's unable to be corroborated:
> I had understood the President to be requesting that we drop any investigation of Flynn in connection with false statements about his conversations with the Russian ambassador in December. [...] Regardless, it was very concerning, given the FBI’s role as an independent investigative agency.
It will be interesting to see whether any extra information is provided or deviated from during the live testimony.
I've never seen a language with such a variety of built-in data types (e.g. coordinates, tags, email, url, issues). There's support for IPv4 numbers as a base type (tuples) but I can't tell if there's support for IPv6, which shows the trouble with this approach for the language maintainers.
What does a type being built-in do for you extra? In ES6 you can define a template string builder which you could name, for instance, ipv4, and then when you want an IPv4 address literal you say
ipv4`192.168.0.1`
and get your object. Are there other benefits besides a literal syntax? (Not to slag on Red. One advantage I can see is avoiding the call at runtime to the ipv4 function.)
I'll add to my reply, because this is a really good question.
Red doesn't have all types in place yet (e.g. date! is coming, and maybe an @ref type, among others), but can still load the following:
at 10:00 send gregg@host.dom a link to http://red-lang.org (216.239.32.21)
delete %/c/temp/junk.dat
assign #DECAFBAD-7337 to John
make the main window 800x600 with a color of 255.0.0
answer: yes
Here's a quick console session showing what types it found:
>> blk: [ at 10:00 send gregg@host.dom a link to http://red-lang.org (216.239.32.21)
[ delete %/c/temp/junk.dat
[ assign #DECAFBAD-7337 to John
[ make the main window 800x600 with a color of 255.0.0
[ answer: yes
[ ]
== [at 10:00:00 send gregg@host.dom a link to http://red-lang.org (216.239.32.21)
delete %/c/temp/junk.dat
>> unique collect [foreach val blk [keep type? val]]
== [word! time! email! url! paren! file! issue! pair! tuple! set-word!]
And you can parse at that level:
>> parse blk [
[ some [
[ 'window set val pair! (print ["size:" val])
[ | 'assign set val issue! (print ["issue:" val])
[ | 'link 'to set val url! (print ["link:" val])
[ | skip
[ ]
[ ]
link: http://red-lang.org
issue: DECAFBAD-7337
size: 800x600
Of course, you could do something similar in ES6. If you use template literals, your data might look like this:
at time`10:00` send email`gregg@host.dom` a link to url`http://red-lang.org` paren`(ipv4`216.239.32.21`)`
delete file`%/c/temp/junk.dat`
assign issue`#DECAFBAD-7337` to John
make the main window pair`800x600` with a color of color`255.0.0`
name`answer:` bool`yes`
That does look handy! I guess there must be a tradeoff in having your text default to meaning plain words if you mess up the syntax? Versus hopefully getting an error in the ES6 case.
You can always get errors of course. The new `load/trap` feature gives you more flexibility in that area, but there are limits as with anything. Pretty handy for CLIs, though, when you expect your audience to know what "syntax" even means. :)
Yup. We often write code like normal programmers, but sometimes we do build up vocabularies more, even when not using `parse` to write DSLs.
"Red or REBOL" = Redbol (sounds like Red Bull) :) And where Perl has Mongers, Ruby has Rubyists, Python has Pythonistas, and Rebol has Rebolers, Red has Reducers.
Ha, Reducers is a good term, considering: the goals of Red (reducing complexity being one), the small size of Red (and REBOL) programs that get non-trivial things done, and finally the size of the software itself (the interpreter - and also compiler in the case of Red). Even the small EXE sizes, in fact (though I've only created EXEs for small programs so far, with it).
One of the key reasons for having a lot of literal forms is because REBOL was designed as a messaging language. You can think of it as a data format as much as anything. Template literals in ES6 help with DSL support, which is fundamental in Red's design. It doesn't mean you can just include anything in Red, but the wide array of native forms lets you build a lot of embedded DSLs without resorting to string parsing. Being able to parse at the block level (i.e. datatype level) is really nice.
A couple other new features make dealing with non-loadable input easier too. You can use macros to pre-process data, trap errors that `load` triggers and still get back a block of values, or spec some simple rules in `system/lexer/pre-load`. That's another way we might deal with IPv6 values.
Yes, a message format. What I would add is, that today ppl are using JSON, not realising, that it is de-facto a Rebol, or at least strongly inspired by Rebol. Well - who wants to use cryptic formats anyway, right? :-)
The tuple! type supports 3-12 segments, but only 0-255 in each segment, which is a byte. So it's used for colors, IPv4, and can be stretched for custom purposes. IPv6 doesn't have a literal form, though it's been discussed. One of the problems is that lexical space is tight and supporting it specifically may lead to ambiguity with time! values. Also, the colon is an important delimiting character, which makes having hex coded value ambiguous as well.
>the colon is an important delimiting character, which makes having hex coded value ambiguous as well
In IPv6 or in Red, you mean?
In IPv6 the colons are there for convenience only, with the rule being that leading zeros can be omitted and that two or more consecutive groups of all zeros can be replaced with ::. You can only have one instance of :: otherwise it would be ambiguous.
For example, the IPv6 address ::1 is actually 0000:0000:0000:0000:0000:0000:0000:0001.
Likewise, 2a03:2880:fffe:c:face:b00c:0:35 is actually 2a03:2880:fffe:000c:face:b00c:0000:0035.
Once an IPv6 address has been expanded to it's full non-abbreviated form you can safely strip it of colons and use the resulting hexadecimal value to uniquely represent that address.
If you were talking about colons in Red and not in IPv6, disregard what I said.
Language is still in active and early development, so it could be added. Having primitive types for a lot of things makes for some very short, yet still easy to read code.
The Red website has it somewhere, but they're focusing on the Lang and not the site at the moment, so it might be hard to find. I think the Rebol website (successor language that is mostly compatible although interpreted only) should have a lot of those.
Is there a recommended way to sync this with a remote server or service? My interest is to share the info between devices. I suppose I could just use a git repo, but wondering if there's a less manual way.
Dropbox works well, as does (oddly enough) iCloud. Syncthing also works well enough too. I simply simlink whichever choice I make back to my home directory, and it works as expected.
Not quite as much activity as Scala either. I think the good thing is that functional languages as a whole aren't going anywhere, it's just that the jobs for them are spread very thin over several languages.
For workplace, sure. But the only reason I don't run exclusively on Mac or Linux is gaming. I've spent a lot of money and time in that ecosystem for that single reason.
There's a lot of people that care about gaming, even if you don't.
This will hardly change, back on my hard GNU/Linux days I came to realise that the gamer/demoscene culture and UNIX culture are totally opposed to each other.
The gaming and demoscene cultures don't care 1 second how much their tools cost, the openess of hardware and software tooling, rather the achieved results and getting their stuff on the hands of users, regardless how.
The GNU/Linux culture is all about the ideology of having stuff for free, replicating a desktop experience as if CDE was the epitome of UX, fulled with xterms.
Of course I am generalising and might get tons of counter examples, just noting my personal experience regarding friends and co-workers.
> The GNU/Linux culture is all about the ideology of having stuff for free
Uh, no. It's about having the freedom to fix, improve, or otherwise modify the software you use. Being free-as-in-beer happens to be a requirement for that, but it isn't the goal. Think about it this way: free software developers get paid to do work, instead of getting paid for having done work like proprietary software developers. You pay me to implement feature X, which is then released to the world for further improvement in the future.
The point I'm trying to make is no one wants commercial desktop software on Linux. We want software we can fix and improve without requiring anyone's permission.
If the desktop APIs break all the time and there are lots of incompatibilities between distributions, it is really hard to sell commercial applications on GNU/Linux.
Lol KDE has many flaws but bloat isn't one of them, I get the feeling sometimes that the presence of several ultra-ultra-light "desktop environments" on Linux causes people to think the major ones are "bloated" when in fact they're much smaller than the DEs on Windows/OS X. FWIW "slow under certain circumstances" does not necessarily imply bloat b/c a single badly implemented feature can cause slowness but that's not the same as bloat; try enabling compositing in some old versions of Xfce (basically right after it was added, maybe Xfce 4.2?) and you'll see what I mean real quick.
It is a matter of taste, of course, but compared to Windows 8 and Windows 10, common Linux/Unix desktop environments like MATE or Xfce are very pleasant to use.
