vladev

Interesting that they use Rust for most things, rather than Deno. I would've expected more dog-fooding on their part.

You can use the `--local` flag to build on your own computer/CI/VPS. `eas build --local -p ios --profile production` can locally build you an iOS bundle. Don't expect it to work out of the box, though. Your machine should have all the XCode tooling correctly installed and configured. Works for Android as well.

I would say that Arch's philosophy is about Exposed simplicity vs Hidden complexity. The wiki is extensive and covers a lot of cases one might stumble upon. Sometimes it feels like Arch's goal is to teach you how it works end-to-end. As a byproduct you get a working OS.

You'll be surprised, but it's RedHat that made most of that happen. A lot of the important Linux projects are developed mostly by them - Gnome, Wayland, NetworkManager, Pipewire, flatpak, etc.

Ubuntu, on the other hand, seem to like to do many things their way. Like aggressive patching. I recall fontconfig being heavily patched from upstream. Then we have Mir (now almost abandoned), Unity (abandoned), snap (flatpak, done differently, not yet abandoned :).

Note that there's also streamlit [1]. It uses regular python files, rather than notebooks, so they can be easily version controlled. And it has more UI tools.

[1]: https://streamlit.io/

We've been using Zoom for the past 2 years and their Linux support is outstanding. Not the prettiest of UIs, but very reliable.

I have another HiDPI laptop with the same wireless card (Intel 7260). I don't think your router is the problem, I'm experiencing the same issues. When I'm not in the same room as the router signal used to drop 50% of the time. Few driver updates later things are much better, but it still freezes sometimes. Consider disabling the power saving options - it does help. It seems Intel totally botched it with this card as the Internet is littered with people complaining about it, including Windows users. It seems the Windows drivers have it covered now, but the Linux ones are still catching up.

Regarding the HiDPI - Chrome is the only thing that doesn't play, but since I'm a Firefox user, that's not a problem. Gnome 3 handles it quite well. Yes, some apps (i.e. Skype) get their font rendering a bit wrong, but otherwise it's fine. But the crisp fonts are something I'm not giving up.

I actually wonder if it can be done even more elegant with RxJS?

I think RxJs[1] can help here as well.

[1]: https://github.com/Reactive-Extensions/RxJS

Could you share your setup - Distro, Desktop Environment, settings, etc.

I wonder if HiDPI support for Linux (and Windows) finally works.

Edit: just grabbed the community edition and the answer is... no. Even with -Dis.hidpi=true - no luck.

I'm hoping to start seeing projects in Go because Go gives them an advantage, not for the sake of it being in Go.

This is very dense code, and takes some getting-used-to in order to read. What it achieves is beyond the reach of many languages.

All it does is convert a Seq (sequence) to a lazy stream that will infinitely cycle through the values.

    Seq(1, 2, 3).cycle.take(8).toList
    res3: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2)

It will work for any seq-like structure (including List. Vector, Queue, etc.)

If you try to use it with anything else, like a Map, it won't compile.

Also, note from my example that it's generic and the resulting List is of the correct type.

Just like novice JavaScript developers struggle with "Why 'this' changes here?", it requires some experience with the language.

You are correct that implicits are a sharp tool. Thankfully, the Scala community knows that nowadays and they are used for a fairly small number of cases - pimp my library (add methods to Ints, Strings, etc.) and typeclasses.

You might try Venkat Subramaniam's Scala for the Intrigued [1]. He's a very good speaker.

Regarding Scala's complexity - some more advanced features are presented in those slides. Imagine watching a talk about Python where they talk about decorators and meta-classes.

[1] https://www.youtube.com/watch?feature=player_embedded&v=grvv...

I can't wait to see all the broken applications/unreadable small fonts on my Linux.

I've been excited for a high density display since Apple announced the retina display, but I have a gut feeling that it will take a lot of time for the Linux desktop to support it properly, if ever.

Honestly, I mostly share(d) your opinion, but am starting to see Go in a different light. The problem is that the community pitches it against C/C++, where Go, with its GC, just doesn't fit well, and Java, whose runtime and libraries is still miles ahead (fast GC, for one).

However, Go seems to be very good at what Python/Ruby/Node.js/Perl are good at. It provides a simple, clean language with more guarantees and better runtime (mainly the cheap goroutines). I see Go taking some of their role for web development, simple tools (Go programs produce a single binary - very easy to distribute).

IntelliJ already provides decent support for it, including auto-completion. I assume with the new pull-based type checker similar things can be done for vim, emacs, etc.

For me, the killer feature of Opera has always been the ability to reflow text to fit any size and zoom. Can anyone confirm this is still in?

I've actually found a sweet spot for a tablet. More than a year ago I ditched my smartphone for a Nokia C3-00. This phone has 2 weeks (!) of battery life and I use it only as a phone - it never drops calls or dies. I use the tablet (Galaxy Tab 8.9) for everything my friends struggle on a phone - much bigger screen for reading, bigger keyboard, more battery. It fits perfectly in the bag I always carry with me.

Note that I don't compare it to a PC - a real computer is a lot more productive when it's around.

I wonder how Linux desktops will handle the screen - I imagine lots of tiny, unreadable text.

From the release announcement on the mailing list:

Some of the highlights are:

* Optimized handling of processes in the VM

* New internal process table allowing for parallel reads and writes

- optimized run queue management

- optimized process state changes

* "Non-blocking" code loading

* New internal port table, and rewrite of scheduling of port tasks.

* Dynamic allocation of port structures, allowing the default for maximum ports to be raised to 65536 (from 1024) Support for UTF-8 encoded Unicode characters in source files.

* Inets application: The http client now support HTTPS through a proxy

* Asn1 application: Major cleanup of back ends and optimizations of mainly decode for PER and UPER.

* The experimental features parameterized modules and packages are removed. An alternative compatible solution for parameterized modules is provided here https://github.com/erlang/pmod_transform.

* All built in functions BIF's (even if they are implemented in C as part of the VM) are now visible in the source code of the module they belong to, including their type specs.

* The Wx application now compiles and is usable with the unstable development branch of wxWidgets-2.9. This means that wx can now be built on 64 bit MacOsX as well.

You can find the README file with more detailed info at http://www.erlang.org/download/otp_src_R16A_RELEASE_CANDIDAT...

There is giter8[1] for Scala. I wish they would join forces to make an universal JVM project templating tool.

[1]: https://github.com/n8han/giter8

Coroutines (ability to send values to generators, actually) have been in Python for quite a while, but I'm yet to see a decent use of them... When you add exceptions in the mix things start to get downhill.

Arch Linux will probably get it in a couple of weeks.

Android, on the other hand, will take much longer. It's sad as there are so many goodies in this for ARM, especially the multi-platform support. This will make updating Android version a lot easier (for manufacturers, hackers). Right now the one of the bigger issues is updating the kernels (and the closed drivers, to be honest).

I installed the ttf version in Arch Linux and it looks awful. I guess it's freetype2's fault.

Update: I bit the bullet and installed the Infinality patchset. The result is astonishing...

I haven't used Slackware, but all of the points you mentioned are valid for Arch Linux as well.

I've used bpython a lot in the past - mostly for it's instant syntax highlight and autocompletion, but I recently discovered ipython qtconsole and I can say it's much better (yes, it's not in the console, but I'm ok with that). Its syntax highlighting is as good as bpython's, but allows me to use it like a text editor and go up a few lines, edit, execute. Bpython cannot do that.

Also, bpython is a bit buggy when it comes to pasting about a page worth of code/string. In the nice case the syntax highlight gets confused. In the not so nice - it becomes completely unusable, so that I have to kill it.

This seems like a nice idea, but - this could be just me - my commits are rarely a couple of changed lines. I usually commit on an "entity" basis where I make one class/module/function along with the tests for it and commit.

Maybe a tool like meld[1] (which already supports diff-ing between your working copy and HEAD) gaining this capability to step through commits would be quite useful.

Still good idea, though!

[1]: http://meldmerge.org/

2012: Python

    "{:10.2f}".format(x)