AWKWARD ZOMBIE

Holy crap, enterprise technology is a lot of fun, but it's so daisies slow on my server...

Trying to install Windows Server 2012R2 onto my ESXi host while I am cloning the VM template and moving some VMs from one folder to another, all on the same datastore. It's hellishly slow. I even managed to crash the vCenter Webserver while doing it!

I need more servers...

Oh man the R9 290 is quite a steal atm at 300 euros, and the 300 series hasn't even been announced yet. I was able to put together a pretty beastly gaming rig for a friend for a 1000 bucks.

Is programming a valid topic for this thread?

I just made a big step forward in my understanding of the way compilers organize routines and how data segmentation works and it helped me come up with my own supercharged alternative to Enums in my pet programming language which doesn't support them natively and I think it's pretty cool. They are more powerful than regular Enums in that I have total control over their implementation, and they're not actually complicated to implement. I've started refactoring my game to make use those (it's super simple thanks to extensive use of type inference all over the codebase), for e.g. keyboard keys and modifiers and some physics and I plan to use them for resources like graphics and audio. This allows static compile-time conformity checks and thus gets rid of potential bugs that could creep up if I just used unconstrained primitive constants. My pseudoenums can use either expanded or reference types as I see fit and provide additional logic for perfect encapsulation without actually taking up more memory than the arbitrary primitive types they inherit from.

*exults logically*

That mostly makes sense to me!

I wish I had 15% of the technical knowledge that it sounds like you have. I can write a for loop. :/

It definitely is! It seems like you're doing more advanced stuff than me though, so while I kind of understand what you're talking about, I'm afraid I don't have any useful input on it xD. What language were you using again? I remember you talking about it before.

Eiffel! It really is the most well-designed language I've used, but it's unfortunately also very obscure. There aren't a lot of libraries for it, the IDE is not super stable and online documentation is sparse and outdated (when looking for specific things you usually end up on websites from 1997-2004 where the syntax isn't even applicable anymore). It is super expressive and clean and favors encapsulation and information hiding, and it's at the same time almost as powerful as C++ but with a syntax that's infinitely better.

It is based on two major principles it pioneered/codified: design by contract and multiple inheritance.
Design by contract is generic enough that it should be used in more languages (some have started implementing it). The gist of it is that every routine comes with preconditions (conditions that must be satisfied when it is called, for example: argument 1 must not be null, argument 2 must be > 0, the current object must be in a given state...), postconditions (conditions that must be satisfied when the routine ends, for example: the result will not be null, the result will be > 0 if the object is in this state but < 0 otherwise, the current object will now be in a given state...) and classes come with invariants (verified every time any of the class' routines are entered and exited to ensure that the object is always in a coherent state). Those are declared in a such a way that the compiler only considers them for development builds and removes them entirely during optimized builds, so it does not affect the performance of the final product but ensures that the program is always working as expected. It serves as both unit tests and documentation so it helps to avoid bugs and figure out usage of routines without looking at their implementation.
Multiple inheritance is also a very cool and powerful feature that I haven't seen used in a convenient way in other languages I've worked with. When used cleverly, it avoids any and all code duplication, and it makes polymorphism extremely helpful. Not only do you have to write less code because you don't have to implement 10 variations of every routine for every entity (or 10 times the exact same routine, looking at you Java!), it also opens the way for specialized interfaces. For example, the LIST class (read-write) inherits from (among others) SEQUENCE, which is read-only. So if a routine takes a SEQUENCE as an argument, it means it will not modify it. There is also the READABLE_STRING family, which are read-only strings from which read-write STRINGs inherit. It's similar to const in C++ but it's built into the types themselves.

There is also feature export parameters which are immensely more powerful than most' languages private-protected-public visibilities. It allows you to make sets of features (members or routines) visible to types you explicitly declare. For example, the creation procedures of my key wrappers is only visible to the one class that's supposed to handle them, so I guarantees that all instances come from that manager and are thus correctly handled. You can also make it so only other instances of the same class can access a set of features so that e.g. you can tell an instance to copy the internal state of another one but that internal state will never be accessible from the outside.

Type inference is an extremely useful feature that I haven't seen in any other language yet (C++11 kind of has it but not in the same way). Instead of declaring an explicit type (be it on an attribute, a function's return type, routine arguments, generic parameters...), you can specify that it will be the same type as some other feature, or some other class' feature.
For example:
///
my_list : LIST[G] -- attribute declaration: a list of G

set_my_list(a_list : LIST[G]) -- Explicit argument type

set_my_list(a_list : like my_list) -- Inferred argument type
///

The second one will not need to be refactored if we decide to change the type of my_list. Those are resolved at compile-time so there is no downside.
My implementation of keyboard input handling has several layers of cascading type inference that all have the same root (a NATURAL_16, i.e. 2-bytes unsigned int) virtual code representing the key being pressed, so all it took was to change the type of that attribute from NATURAL_16 to my custom enum type and it affected the whole stack. My enum type is more or less a descendant of NATURAL_16 so it could be used the same way if it needed to (and could be used transparently in place of an actual NATURAL_16 with no problem) but the compiler will not accept the opposite: you can't assign a regular NATURAL_16 to that field. That enum type only exports its constructors to one specific class (the enum proper), therefore all values must be named valid entries in the enum.

So we're doing a sorta big project in school this quarter with a 9 person team counting 4 programmers. We were going to set up a pretty spiffy data pipeline involving Kafka clusters to do some reactive programming, which is completely outside what we learned in courses to the point that some teachers and school-associated researchers asked our main guy responsible for it to give them a seminar about it. However, the customer just decided "new" technology is scary and that we should just stick to conventional stuff, so now two weeks of work are basically down the drain. Fun times.

ok kids my headset has decided it wants to be the biggest piece of shit in the world despite only being like 3 years old.

what's a good replacement that's under $100 and sounds decent and is wireless

I did it! It took me a month but I made my own simple XML tree parsing library that's flexible and has a nice API and seems quite fast and efficient enough already.
All so I could use a graphical level editor that outputs XML files to generate level data for my game instead of the ugly ad hoc implementation I had before.
I thought of releasing it as a standalone project called Simple Eiffel XML but I'm not sure that's a well thought out name.

I've been playing some more with multithreading.
In the last months I started using wrappers for lambdas in my game project because some tasks that were performed in a background thread (e.g. preloading a stage when the character uses a door) could not perform everything themselves (like rendering graphics, which has to be done by the main thread). I created wrappers that checked whether the calling thread was the main one, and if it wasnt it would schedule its inner lambda to be run by the main thread at the end of the current cycle and return once it was all done.
Last week I reworked it so that my old wrappers are now actually fully-conforming specialized lambdas that schedule themselves as needed, eliminating a layer of indirection but most importantly allowing polymorphic substitution wherever regular lambdas are used without changing anything and without the underlying libraries having to know about it. More flexibility!
Yesterday I implemented Eventuals, which is a thin wrapper that handles the evaluation of a variable in an asynchronous way, meaning it doesn't block a thread until the result is actually used. Super simple and efficient.
This evening I combined both and developed main thread eventuals, which is like a main thread function but doesn't block the caling thread during the evaluation. So Thread 2 can spawn Thread 3 to wait for Thread 1 in its stead.

I don't actually have a use for that yet but it's fun.

So our team has just delivered it's first project (an enterprise-scale webshop) and we are looking to turn the project into a template of sorts to deliver future projects. So I'm going to try and refactor this monolith into something more component based and try to achieve some separation of concerns. Since the framework we use is cartridge-based I'm going to attempt to restrict third party integrations to their own cartridge. I'm also going to create a Business Logic Layer instead of having fat controllers.