accatyyc

Try Firefox Nightly. Runs super smooth on my Mac, and I think WebRender is what solves this for many people.

That reason is probably to discover AirPlay speakers on the network, right? Sounds useful to me

As someone maintaining Obj-C libraries, I can see why. Usually the Swift examples are 90% the same thing so maintaining both is just a boilerplatey hassle. And really, I expect all competent iOS developers to be able to use an Objective-C API from Swift without even thinking about it, much less require specific examples.

With that said, I do find it useful to write unit tests in Swift, just to see that the Swift API looks as expected. So that’s one way to add examples.

Telegram for example supports most of Discords features, is native, and is incredibly fast.

I use Discord and like it, but it is incredibly slow at starting, switching rooms, and even just loading new messages.

But the most aggravating thing is that I can't type a message on mobile if I don't have internet connection. It requires connection to load the input field. Affects me every day in elevators. Most native apps just lets you write your message and sends it when connection is back.

Fine, Discord is useful, but I must respectfully disagree that their app is good. And it is definitely possible to make natively.

The issue itself is that Chromium uses a lot of memory. And electron basically just runs Chromium. Except that since each Electron-based app ships its own very isolated copy of Chromium, the following problems occur:

- The operating system cannot share memory between different Electron processes. Normally if you start many processes of the same binary, the memory is shared and only copied on write. Since each Electron app is a different binary (even though they are 99% identical) they each eat memory.

- The above applies to disk size as well. Electron apps are usually huge, and 99% of the binary is the same as all your other electron apps.

This is mostly why I'm against electron. If electron worked like the JVM and each app shared a runtime, many issues would be solved, including many electron apps running old, and vulnerable versions of Chromium. Now it's only updated if the developers decide to ship a new version.

Never had this problem. How did you install/how do you launch it? Does it require root access for some reason?

Yeah, this guy actually PHPs, in contrast to most of the "php is so stupid" people

Wow, thanks for reminding me. I totally forgot this game existed. It was fun!

All this sounds very useful! If I ever decide to make a game I will definitely use a spreadsheet as database.

Cool, wasn't aware of that one. Reinventing the wheel once again :)

Adding custom CSS/JS to Fastmate would be pretty simple, I might just do that as well.

Is there anything that you miss in your fluidapp setup that could be added to Fastmate perhaps? Thanks!

Is there a better wording? The wrapper is a native OSX app, adding some native features the web app lacks. Memory usage should be roughly the same as running it in Safari, right now around 23MB on my computer.

This is a small project that I made mostly for my own use. I did learn about Fastmail through HN, so maybe someone else here has use for something like this!

Most universities with computer science have courses in networking, which usually includes programming a router. I’m sure some courses are available online

On my computer, "bare" Chrome with 0 tabs open still uses ~100MB of memory. If Electron would just use 100MB for the base compared to 100 * number of open Electron apps, that's still a pretty big win in my book.

One big problem with Electron apps today IMO is that different apps cannot share memory, even though 90% of them is the same (Chrome/V8 etc).

That would be solved if you had one Electron binary that started each app, much like a JVM. They would still be different processes so one app couldn't bring down another, but at least they would share memory pages and copy on write which would make the multi-electron-app world better. (IMO)

It would also have the benefit that you could update once and not run an old chat app with old Chrome security issues, until each developer decides to update Electron. But I guess the argument against that is that it's no longer "truly cross platform" since an Electron app may have to support multiple Electron versions. This is how things always have been though, developers just seem a lot more lazy about it nowadays.

Since Lua “arrays” are just tables with numerical keys, couldn’t you just start at 0 if that’s your preference?

I think there’s a much simpler example of how code is data:

    (hello world)

That’s a list containing two symbols. So it’s data. However, if I evaluate that list, it will call the function “hello” with the argument “world”. So it’s also code.

Incidentally, lists and function calls are identical in lisp, hence code is data.

I think the article just complicates it by introducing macros.

As someone else who have hired developers I agree with the parent post here.

Examples include:

- totally oblivious to standard library for the language/frameworks, reimplementing the most basic things (poorly)

- even after a 3 year CS education, lacks basic understanding of object-oriented programming/class hierarchies

- has trouble implementing even simple if/else-conditions without help

I’m talking really basic stuff here. You’d be surprised. I assume that if you are self-taught, you have the interest and because of that already much more knowledge than many graduates.

I usually don’t use the debugger to debug language features, but rather my own logic. It’s very useful to step and inspect parameters when you can’t really see your own logic errors.

Reminds me of all articles attempting to explain how simple monads are

Doesn’t seem like anyone assumes that. I’m interested in this stuff, but having it visual and physical like that would spark my interest even more. Seems like a no brainer that it makes students learn without studying a text book

They do use version control. They put each version in a folder named after the date

Guess I’m stupid! I played the 10 hour demo, and then pre-ordered, based on my own experience being that the game is really fun. The reddit complaints are blown way out of proportion.

The way I learned was by figuring it out myself through hacking. I decided to start with a program that could set the color of a single pixel, then tried to figure out how to draw a line from that, and from that to a triangle. After that, try to use the Z value of your points to draw a box from lines with some kind of perspective. With a good background in math, most of these algorithms should be relatively simple for you to figure out. After that, you’re not too many lines of code from rendering full 3D models. Doing it this way, I learned how shaders work by having to figure out manually why they are actually needed. Here is my project, which can now render textured objects in real time with multiple light sources: https://github.com/accatyyc/c-3do

I still have no idea how to do “correct” perspectives. This is just something I hacked together until it looked good.

I can very much recommend doing a project like this. You will naturally figure out how 3D graphics work, and it’s simpler than it appears.

I’ll join you and show off mine as well! Runs in terminals, and also has a rougelike adventure mode where you navigate the board with a character.

https://github.com/accatyyc/terminal-mines

Same applies to IVPN, FWIW.

Agree with this! I love researching and acquiring quality things. Doesn’t mean I have too much stuff. I love throwing stuff away, but will also enjoy spending a lot on stuff I care about. Quality above quantity.

Or... you can just fix the warnings before commiting. We have no tolerance for warnings on pushed code, and this has seriously never been a problem.

It’s just annoying to have to remove every unused variable/parameter when trying changes out.

Why should it? I just don’t get the obsession. As long as no one commits any warnings (and it’s easy to have a no warning policy), then I don’t see why it should be enabled. Sometimes I just quickly wanna throw in an unsafe printf here and there, or not change a type in every place when iterating and trying changes. It’s just strange to disallow yourself to try quick changes that warns because they might be unwanted in certain situations.

And don’t worry, if the new idea I’m trying is worth it, I will fix it up so it doesn’t have any warnings. And I saved a lot of time by not fixing all these warnings on the previous 2 ideas I tried.

One might say complicated, I say feature rich! I think it's a shame that all focus is on Swift right now, because Objective-C has seen so many improvements in the last years, and it's now an incredible, mature language IMO. Wonderful to work in, and while I do dabble in Swift occasionally at work, and it has some neat features, I would still not choose it above Objective-C for any new stuff I'm building.