elFarto

They also issued take downs to other people streaming/commentating over it almost immediately.

We've been using this at work, and it's been fine without installing anything to the cluster. The only thing missing is the CPU/Memory/Filesystem stats, which is no great loss.

I still use it for all of my Youtube subscriptions. I have about 50 channels in there.

CCP used one for Eve Online. They stuck their SQL server on it.

Ubiquiti has got you covered:

https://unifi-led.ui.com/

I've tried using Bridget[1] before, but didn't actually manage to get it working properly (although the problem was likely firewall related).

[1] https://github.com/kvaps/bridget

> Kerberos can’t survive in untrusted networks...

Wasn't Kerberos designed to work in untrusted networks?

The XPath for the second one would be:

//root/item/key[text()="Name"]/../value/text()

There's a new Honda 'e', that doesn't have side mirrors at all, and just has two screens inside.

https://www.youtube.com/watch?v=pEKq8jmckz0

Interesting, this mirrors a lot of thoughts I've had on package management on Linux.

I'm not sure I like the idea of using file system images as packages, wouldn't that have overhead in terms of the sheer number of mount points you'd need, and additionally the permissions needed to actually mount it.

Keeping each package separate is a good idea, I certainly think the current 'soup' method of package management is not ideal. By 'soup' I mean adding files all over the place, and then giving it a good stir by running some scripts; it's very difficult to get back to the state the system was in before the package was installed without doing extra work to keep track of those changes. I was looking through the Alpine package management system, a lot of packages post-install script would add a user, but the remove script rarely removed that user.

Ideally packages shouldn't care where they're installed to. If a binary in the package needs to know where it's installed to, it's possible to work that out at run time (even for libraries, although it's not that straight forward).

In my idea for a package manager, each package would have different types of files in different directories, e.g. all command line binaries would be in /bin, all libraries in /lib, all fonts in /share/fonts, etc. In addition, it would be possible to have scripts run when another package was installed that provided a set of files you could use, for instance: when a package that contains fonts is installed, the package that is responsible for fonts on the system would add the relevant directory to the config and refresh the cache.

If a package had a library in /lib, a package could update /etc/ld.so.conf and refresh the cache. Linking files to shared directories would be avoided as much as possible (you probably need to do it for /bin). Using an exchange directory is somewhat of a crutch, patching the system to work as applications expect a traditional Linux system to work.

Hmm, this post seems to have just turned into a bit of a brain dump.

He's using it to read the entire files contents into memory, and re-running the lines() method from the now in-memory buffer, presumably to remove any disk I/O from bottle necking the lines() function.

Not the best method to use, probably better to use the Files.readString method.

The first issue I can see with that code is it's not doing what he expects. He does this to read the file into a StringBuffer:

  bf.lines().forEach(s -> sb.append(s));

However, this ends up reading all the lines into one giant line, since the String's that lines() produces have the newline character stripped. This leads to the second lines() call to read a 23MB line (the file produced by gen.py). This is less than optimal.

The fastest version I managed to write was:

    public void readString5(String data) throws IOException {
         int lastIdx = 0;
         for (int idx = data.indexOf('\n'); idx > -1; idx = data.indexOf('\n', lastIdx))
         {
            parseLine(data.substring(lastIdx, idx));
            lastIdx = idx+1;
         }
         parseLine(data.substring(lastIdx));
    }

Not the prettiest thing, but it went from 0.594 GB/s to 1.047 GB/s. Also, it doesn't quite do the same as the lines() method, but that's easily changed.

Technically yes, but it's only a PCIe 1x Gen2 slot, so only 500MB/s of bandwidth (4x Gen3 is ~4GB/s). You'd be better off with a USB 3.0 to M.2 adapter.

They do have a liner, here's a video of someone removing the can from the coke:

https://www.youtube.com/watch?v=X1pB6O6AYMU

Honestly I'm surprised no one has suggested replacing SMTP with a HTTP POST request. All you would need is an email address -> HTTP URL conversion (which I believe something like WebFinger already has). Then just POST your message to that URL and you're done. ISPs can run proxies that just authenticate that requests are from users and forwards them on.

Wolfenstein 3D was ray-casting, not ray-tracing. There is quite a difference between the two techniques.

Are those front tyres even on the right way, they look backwards?

Any chance that you could just fork it? Create cmd2.exe, hell you could even open-source it.

It's pretty trivial to de-DRM Audible downloads. Once you've got your key, you just need to download the AAX file from them, then run ffmpeg over it:

ffmpeg -activation_bytes <your activation bytes here> -i file.aax -c:a copy file.m4a

I have a few more commands to extract and re-add the artwork.

I wonder if you could get the same functionality of AWS, with the same implementation of B2, by having a single URL to POST files to, that simply sent a redirect to the correct location (apparently there's the 307 HTTP status code for exactly this).

E.g:

  => POST https://upload.backblaze.com/bucket/file
  <= 307 redirect to https://pod-000-1007-13.backblaze.com/b2api/v1/b2_upload_file/...
  => POST https://pod-000-1007-13.backblaze.com/b2api/v1/b2_upload_file/...

I enjoyed the Expeditionary Force audio books (there are 5 of them so far), read by R. C. Bray. Very funny, one of the few books to make laugh out loud while listening to it.

My other favourites are Pandora's Star and Judas Unchained by Peter F Hamilton (and the rest of the books in the Commonwealth series).

I had this problem with Gitlab until I worked out how to use it's built in cache mechanism to save the .m2 directory, the bit I was missing was to force maven to use a different location for that directory.

I'd like to add to that list, the GNOME Header Bars (the merging of title bar/menu bar/tool bar) into what ends up being a hodge-podge of button and menus which is so radically different between applications I never know where to click.

Bonus points to Nautilus, which somehow manages to have 2 buttons side-by-side that look like hamburger menus, the actual hamburger menu and view as list.

I really dislike everything looking and acting different, it's like having to learn a new language just to talk with a new application.

You should already be able to implement this using the If-Modified-Since HTTP header. The server only needs to send you back articles in the RSS feed that have been added after that date. The If-Modified-Since value is meant to come from the previous responses Last-Modified (not a timestamp you make up), so that side-steps timezone issues.

They're removing the streaming APIs, these allow a single long term connection to receive tweets, follows, etc... in favor of a Webhook solution.

The issue is that there are not comparable solutions. The streaming API allows a user to connection directly. With the webhook solution it has to all go via 3rd party server, and you need to pay for it.

I really like the Equinox Clock[1], which was made before easily available addressable RGB LED strips, so each LED is individually placed.

[1] http://www.bramknaapen.com/equinox-clock/

> Can someone clarify this for me? Are OpenGL/D3D buffers that get stuff memcpy'd into them by the CPU actually "slices of GPU memory," or are they more often reserved driver memory that eventually get DMA'd to the GPU?

The answer is, as with all things OpenGL, it depends. You might get back a pointer to GPU memory that you can directly write to, or you'll get back some chunk of system memory the driver has.

The ARB_buffer_storage extension improves matters as you can almost guarantee that you'll get GPU memory, and you can keep it mapped for the entire lifetime of your application (the old buffer APIs wouldn't let you keep it mapped during a draw call). The downside is that you're now responsible for synchronising access to that data.

But as for "is it quicker?", maybe. DMA transfers aren't free, they take time to setup. Usually they need to operate from a limited pool of source memory. If the driver has to take a local copy of your data to copy it (which it will do for every glBufferData/SubData call), then you might as well copy it yourself, GPUs aren't hurting for PCIe bandwidth these days. In addition, you can use a separate thread/CPU core to do the copy, since unlike every other OpenGL call, mapping memory and memcpy'ing doesn't require an OpenGL context.

OpenGL implementations shouldn't be effected by syscall overhead. Historically it's been DirectX that had a syscall per draw call, but I believe both now just write the command to GPU RAM directly.

I have the Juniper VPN working under Linux. Pulse Secure (as it's now called) is supported by the openconnect package[1]. It was pretty straight forward to get working. There's even a Network Manager plugin to allow you to configure it via the GUI.

Since you're running Fedora, you can probably do something like:

  sudo dnf install openconnect NetworkManager-openconnect

[1] http://www.infradead.org/openconnect/

Dubai, day 4, at the 2:30 mark, left hand side. I'm pretty sure they're just painted on the bottom of the pool, not actual sharks.