Ask HN: Ultrawide monitors, what's your experience been like? - <AUTHOR> I need a monitor for work that has lots of space so that I can open up different applications side by side.  I was initially considering buying two separate monitors but am now considering ultrawide monitors as an option as well.  For those of you with ultrawide monitors, what's your experience been like?  Are there any brands or models that you recommend?  Is there anything I should look out for? <comment><USER3> I have a Dell U3818DW and you'd have to pry it out of my cold, dead fingers. I can be working on a document with Word in the middle, a relevant Visio drawing to the left, and an Excel spreadsheet I need some analysis numbers from on the right. It is joy incarnate.

I have VFIO setup so I can run Linux as my main OS and Windows in a VM with GPU passthrough for basically bare-metal speed. The Dell can either switch to that input (of course) or I can do Picture in Picture with a selection of two different sizes. That lets me putter in Linux on my main display while keeping an eye on Windows upates in the PIP (or whatever). The Dell properly scales the screen, unlike the horrible scaling on the Acer that someone else mentioned in this thread.

The glare mentioned by somebody else is not an issue as the Dell has an anti- glare display. Not to mention factory color calibration. Not to mention a three year warranty that even covers you for a single dead pixel. It has USB- Cx1, DisplayPortx1, and HDMIx2. There's a bunch of other nice features too that I didn't mention. If you are a gamer (I'm not), this probably isn't for you as it doesn't have FreeSync / GSync.

Spend the money. It is worth it. Keep an eye out for sales. I'd buy it again in a second.

<comment><USER4> Off-topic but I want to hear more about this VFIO setup.

</comment></comment><comment><USER5> I switched from two monitors to a single, curved, ultra-wide 38" doing 3840x1600 pixels (LG 38UC99-W) about two years ago. I would never go back. I took maybe two days to get used to it. At first it was funny: going back to a flat screen and I would see the _flat screen_ curved (!) but this weird effect disappeared after a few days and now I can use either curved of flat screen and everything always look normal: it's amazing how fast we adapt.

That's 3x 1280 wide columns (I don't always use three columns of the exact same width that said). That's a lot of screen real estate already.

Common setups I use are three columns (say IDE / Emacs in the middle, browser at the left / terminal bottom left / PDF open on the right / another terminal at the bottom left) or two columns. I often also have one virtual desktop with 9 terminals opened.

IMO when you begin to go really ultrawide the pixels "in the corners" are kind far away compared to the others. A slightly curved monitor helps a lot with that.

Now I don't game and don't watch movie on my monitor so there may be better 3840x1600 monitors than the one I picked two years ago.

I try to arrange things logically and always in the same order, so I always now on with "virtual workspace" I'll find what opened. I use a tiling window manager and keyboard shortcuts to resize windows.

Only app I run in full screen is photo-editing software. I take it audio and video editing software would do too.

<comment><USER6> >a single, curved, ultra-wide 38" doing 3840x1600 pixels... That's 3x 1280 wide columns...

This is incredibly important for day to day use. A lot of ultrawides will have a horizontal resolution of 3440. If you want to split that into 2 or 3 columns you will be left with windows sized at 1720 and 1146.67 respectively. Those are weird resolutions. No one is specifically designing programs or websites for a horizontal resolution of 1146.67. However a resolution of 3840 splits nice and cleanly into 1920 and 1280. Those are the standard horizontal resolution for 1080p and 720p. Almost all programs and websites will be designed to work well at those specific horizontal resolutions. Therefore using an ultrawide with a horizontal resolution of 3840 is just going to feel more natural.

<comment><USER5> Yes exactly: back when I bought that screen it just came out (I think) and was quite a price jump compared to a similar but "only" 34" LG doing 3440x1600 (same pixel size, just a bit less pixels). So I thought the way you just explained and decided to shell out the extra bucks to get a 3840x1600.

</comment></comment></comment><comment><USER7> I cannot go back to 27" - ultrawide is game-changing for me.

Basically, it comes down to working on 3 interfaces seamlessly, versus two with a single screen. Think REFERENCE, ACTION, SOURCE/DESTINATION.

Couple that with using Spectacles (for Mac) to move windows in position with the keyboard, and Mouseless App to master keyboard shortcuts, and you're flying.

I considered ditching my ultrawide to buy the new iMac 5K 27", but it was more geared to 2 interfaces, not 3, so I couldn't. Even though I prefer the hardware over my MacBook Air 11" 2015 - maxed out.

I love my LG 34UC80-B 34-Inch 21:9 Curved UltraWide. The Sceptre C305W-2560UN 30-inch 21:9 Super Curved Ultrawide is a great budget option.

<comment><AUTHOR> I was actually looking at that exact model LG, good to hear from someone that owns one.

</comment></comment><comment><USER8> I doesn't work for me, but that's probably very application-specific. I'm not a dev nor a graphic/video artist, my work is motly editing office docs. Why it didn't work for me: 1- OSes are rather bad at handling large monitors. You can't just dumbly Maximize anymore, which is what I always do. Windows positions don't get memorized so your screen is a permanent mess. 2- I need the doc I'm working on, sources, and social/comms/entertainment. That's an ideal setup for 3 monitors and a good stand 3- it's hella expensive. 4- it maps better to how my brain works ?

I want back to 3 medium, cheap monitors, and I'm happier.

<comment><USER7> There is software to resolve issue 1 with keyboard or mouse/trackpad shortcuts for nearly all OSes.

<comment><USER9> can you recommend any good for windows? powertoys doesn't work for me.

</comment></comment></comment><comment><USER10> I use an a 38" Acer 3840x1600 ultrawide.

For 2D windowed applications, it works exactly as you'd expect. Be sure to have tiling support in your window manager for the best experience -- I typically have two windows opened side-by-side, and the Windows 10 window manager makes this tiling easy to do.

Support for ultrawide resolutions in full-screen applications like games can be hit or miss, but it generally works, and you can always fall back into standard widescreen or fullscreen resolutions with letterboxing if it doesn't.

One downside I've noticed is that due to the curved screen, glare from bright light sources (e.g., the sun) that reflects off the screen is somewhat out of focus with whatever is being displayed, which is fatiguing to look at. I don't know if this is a problem with this display in particular, or curved displays in general, but something to look out for.

Overall, I'm satisfied with my ultrawide, and will continue to use a single large display over multiple smaller displays in the future.

</comment><comment><USER11> For the longest time, I was using dual 1920x1080 screens.

Eventually, I decided to upgrade and got myself a 31.5" 4k display. That lasted about 6 months before I ditched it for a 34" 3440x1440p Ultrawide.

I found coding on the 4k screen to be just too difficult, I had to scale the text way up for things to be readable. However, since I use a laptop running Fedora which I connect to through a thunderbolt dock, I found one monitor to be much less... finicky than using two (I'd briefly considered getting two 2k screens). So far, I've been much happier with the Ultrawide.

My wife took the big 4k monitor off my hands and is using it with her mac mini. I'll admit, MacOS does appear to do a better job dealing with a 4k screen than Gnome.

<comment><USER12> I use a 65" 4K screen as my home office monitor. I had a 21:9 monitor before this but i always felt I was missing the top half of my screen. Now admittedly every time I sit down at this I hear my mother saying, don't sit so close to the tv... but I do like having the ability to push things off to the side... it's like a big vertical work top.

</comment></comment><comment><USER13> Copying my answer from "Ultrawide or 4k?" \- [https://news.ycombinator.com/item?id=21451124](https://news.ycombinator.com/item?id=21451124)

> I picked 34" Ultrawide. It works just fine for everything. Easy to read, > almost two "regular" monitors worth of screen space. Gaming on 3440x1440 is > hard to max out (but easier than 4k), but you barely notice the difference > between 3440x1440 and 2560x1080 in most games.

> I actually quite like the aspect ratio - it means I can have 2 windows in > normal proportions (IDE for example) and another one on the side (terminal > for example)

> 1 thing to note; I thought 34" Ultrawide will be bigger screen than it > turned out to be.

</comment><comment><USER14> I had a Dell 38" ultrawide that I loved, but it did not survive a cross- country move so I just replaced it with a Philips 499P9H 49" ultrawide - 5120x1440 - Really the same dimensions as two 27" monitors side by side, but without a center seam

So far, I really like it - But getting it to work at full resolution with my 2013 Mac Pro has been frustrating - It essentially cannot be done at full resolution with a single cable, unless you boot into Windows (also true for Mac Minis, but apparently newer Macbook Pros can drive it) - Despite what you may read, hacks such as SwitchResX will not help here; it's a limitation of the Mac's video card drivers that Apple seem uninterested in addressing.

The "solution", for me, has to drive it using two identical Mini Displayport->HDMI cables as if it were two screens and then have MacOS treat it as a single space. Using identical ports/cables has meant the color temperature on both halves is identical and i cannot tell it is not being driven as a single display, other than the fact the menu bar is only on one half of the screen.

Aside from that, it would be nice it were higher resolution, but the older I get, the less my eyes notice and the extra width is more useful than the DPI.

</comment><comment><USER15> I use the Dell 43". It's not perfect but it's pretty great for the price:

[https://www.dell.com/en-us/work/shop/dell-43-ultra- hd-4k-mul...](https://www.dell.com/en-us/work/shop/dell-43-ultra-hd-4k-multi- client-monitor-p4317q/apd/210-ahsq/monitors-monitor-accessories)

<comment><USER10> I have an LG 43" display at work, which probably uses the same panel as the Dell monitor.

It generally works as advertised, but sitting at distance one would normally site from a monitor (as demonstrated on Dell's marketing in the parent post), the extreme edges of the display aren't visible, because they're in the shadows of the bezel.

This is generally just a mild annoyance, but it can be workflow-impacting. For example, I use Ubuntu with the application launcher bar docked to the left side, which means that the dots indicating which application (and how many instances) are open is on the extreme left side of the display. I have to lean to my left in order to see these dots, because they aren't visible when I'm sitting upright and looking directly at the screen.

Also, while I've gotten used to it, sitting at a normal monitor distance involves a lot of vertical head movement.

Overall, I'm satisfied with what I got for the price, but I would have gotten the same 38" ultrawide that I use at home if I had the budget for it.

</comment></comment><comment><USER16> I needed to constantly move and tilt my head so much it hurt.

My specimen also had some problems with blurriness, I couldn't quite put a finger on what it was exactly, just it was definitely harder reading things on it compared to my previous setup, but this could be just an isolated manufacturing defect.

Got rid of it and went back to two 27" monitors: one primary straight in front of me where all the work happens, I don't have to move head while working on it. One secondary for less important side things. Both are 4K and so in total I have way more resolution this way than with a single ultrawide. Very happy with this setup.

</comment><comment><USER17> I'm on dell ultra wide and not happy with it. The angle isn't quite right except in the very middle, strains my eyes. Going back to dual monitors soon. Also prefer having one in portrait and one in landscape orientation.

</comment><comment><USER18> I have a 32" curved ultrawide (3440x1440) at home and a 32" 4k at work. I work and game from home, and I mostly prefer the ultrawide even though it has less pixels.

For the ~ decade before I got this monitor I used to use 2x24" 1080p displays at home, but always ended up craning my neck using them as you either have the bezel down the centre to fit and then you're constantly looking to the side, or have one monitor way off to the side so it's even less useful. I find myself turning my head much less with an ultrawide for whatever reason.

Compared to the similarly sized 4k monitor I use at work, the one at home is essentially just shorter. It makes using 4 tiled windows not as good, but I don't really miss it (though this could be due to the tiling WM I use).

I don't do a ton of gaming anymore—but when I do, it's awesome. Surprisingly immersive.

I dual boot my computer at home with Linux / Windows, and use Linux as my daily driver with i3 [1]. I do find the monitor much more usable in Linux with i3 managing windows and workspaces than the occasions I need to develop on Windows (on Windows, I hate how windows just pop up pretty much where-ever). When working I tend to keep two windows side-by-side, one for my editor and the other for whatever I'm working on (terminal instance, android emulator, website, etc). I then use hotkeys to switch instantly between workspaces so it's quite fluid, but the monitor plays less into that. When I first bought mine I had visions of using 3 windows side-by-side, but I just never do that in practice for some reason. I also run everything at 1x scale, so the added vertical screen real estate (1440 vs 1080) is quite useful.

I use LG monitors almost exclusively, but that's simply because of cost—they're almost always cheaper than other brands and I've never had any problems with them. They may not be as high quality or stacked as full of features as other brands but they've always been good enough for me.

I'm never going back to dual-screens—to me they seem embarrassingly bad in pretty much every way compared to a single ultrawide these days.

[1]: [https://i3wm.org/](https://i3wm.org/)

</comment><comment><USER19> Love mine, they're way, way better than having two 24 inch screens side by side. But here's the thing — you need a tiling window manager. That's the only way I've found myself actually utilising the 'sides' of the screen and not just the smack dab centre.

I use Amethyst on Mac OS, which is great. [https://ianyh.com/amethyst/](https://ianyh.com/amethyst/)

</comment><comment> ryan-allen I've had so many screens... I've run 3x 27" 1440p (that felt oppressive), 2x 23.8" 1080p (comfortable), 43" 4k (loads of vertical real estate for reading code), and currently on a 35" 1440p 21:9 ultra wide.

Ultra wide is like having two screens, when splitting windows left and right, though I think two monitors is better for work, as you can put one as the primary and one off to the side, you don't want to be looking sideways when working on code.

When I was reading a lot of code I didn't write, the 4k was the best, as it had a lot of vertical space.

The ultra wide I bought for games (it's 120hz).

I'm about to start a new gig and I'll run 2x23.8" 1080p for that.

Phillips make decent 4k screens at 40" and 43" for the money, but they are glossy so no good if you have glare problems.

The nicest screens overall for work I find are the Dell ultra sharp line. They are premium in price but side by side to a cheaper monitor and you can see why!

I have a 27" ultra sharp that is about 8 years old and is still fantastic compared to most mid range monitors, it's worth the investment. 1x 27" is nice, 2x 23.8" is nice.

Samsung make good ultra wides for work, and they make some ultra ultra wides too!

</comment><comment><USER20> I use 3 monitors:

2 x ASUS @ 1920 x 1200 (total: 3840 x 1200) 1 x 42" 4K TCL "TV" @ 1920 x 1080

I (almost) never have a window I want to span monitors (or be larger than a single monitor). I like the organization that the monitors force on me. I use 5 workspaces ("Work", "IRC", "Telegram", "Web", "Music") and in each workspace, the left and right halves (the two ASUS monitors) provide distinct zones within the workspace. In the "Work" workspace, for example, the left side is invariable terminals, the right side is invariable emacs. In the "telegram" workspace, the right side is (Surprise!) telegram, and the left is any other application i need to use while communicating via telegram. Etc. etc.

If I had an ultrawide, it would remove the "bezel" divider between the two ASUS monitors and require me to keep that left/right organization all by myself. Boo.

The TV screen is "special" and not in use normally, but when I use it, it's invaluable because it's huge.

</comment><comment><USER21> I had one for two years. I recently switched back to two 27' inch monitors and I won't ever go back. You'd need to tile it and even then it's not worth it. I don't recommend it, it's too clunky and big. If you're gaming or watching movies on it a lot it's cool, but for coding I'd pass.

</comment><comment><USER22> I have a Samsung 49" 32:9 ultrawide with a resolution of 5120x1440. The primary reason I went with this monitor is that I use two computers: one provided by my employer and another provided by the government agency I'm contracting with. The model I have supports picture-by-picture, which makes jumping between the two computers really easy.

Apart from that, I do really enjoy all the screen real estate. It's nice to be able to have a full-sized browser window and two instances of VS Code all running within a visible portion of the screen. That being said, I'd easily give it up for a reasonably priced 27in 5K display that works over DisplayPort. The extra screen space is nice, but I'd much rather a display that had crisp, high-DPI text.

</comment><comment><USER23> Amazing. I can never go back. Everytime I have to go back to using two monitors it's feels so awkward and unnatural. I didn't think it would have this big of an effect but being able to center windows on the screen and have equal space on the sides really helped my workflow. I'm a programmer. I also got one that is 144hz. It's so smooth. It's such a pleasure to work on. I can read text as it scrolls now! Totally worth the money if you stare at a monitor all day.

I have a 1440p. I would think 4k would not be worth it. Also way to hard to drive

If you have a laptop just make sure it can drive it. And that you have the proper cable. Mine was finicky until I got the proper 8k dp cable.

</comment><comment><USER24> I have 2 wide now. 2 ultrawide would be hard to command the whole field. I could deal with a single ultrawide - as long as it was nearly as wide as my duet? 2 ultrawides would lead to craning of neck. I just bought a card that will drive 4 monitors for a new system, so I will try 2 up and 2 down - <USER2> see how I like it. I could try one up and one down with both ultrawide? In both cases I would tilt the top down a little and the left and right in a little. I do geological drawings, so it is good for spanning to all corners as well and cut and paste from panel to panel as I change stuff around.

</comment><comment><USER25> I've been using inexpensive ~40-inch-diagonal 4K (3840×2160) televisions as monitors for quite a few years and will continue to do so. Current one is TCL 43S405 (wife commandeered the Sony 43X800E). A single monitor makes for far less configuration fuss — multiple monitors coerce distinct assignments and as well introduce discontinuities in the midst of the workspace (of which I was once tolerant, but no longer). I have yet to try anything in the 50-inch diagonal range, which would likely work but the periphery might go largely unused.

</comment><comment><USER26> At work I use a single Dell 38" 21:9 ultrawide curved. Ultrawide + curved is 100% the way to go for productivity imho. Make sure you get a monitor with 1440 vertical resolution and not 1080.

At home I use a single flat 27" 16:9 1440p 144Hz so I can game.

I wrote my own, super simple Windows tool to help control window placement. [https://github.com/forrestthewoods/fts_winsnap](https://github.com/forrestthewoods/fts_winsnap)

</comment><comment><USER27> I am considering upgrading to a 4k moniter or a less-than-4k resolution ultra wide screen. Can anyone with experience in both tell me which you found to be better?

<comment><USER28> I tried an ultra wide monitor, but I somehow found the limited height annoying. I am much happier with the screen space distribution since I have switched to a 43 inch 4k monitor. Mostly using it for coding. Nice to have a full IDE on the left and an emulator or web window on the right. When viewing code, height is quite important to get a better overview of a function or class.

<comment><USER29> At work, I use a 32" 4K monitor for code/web searches + a laptop screen for Slack. At home I use a 34" 1440 rez ultrawide + a 1080p to the side for music/YouTube/Slack.

I don't have a strong preference. But, if I had to choose, I guess I'd go with the 4K setup. When I have 3 documents side-by-side, seamless on the ultrawide, it is really nice and clean. But, I do feel the lack of height. At work I tend to have dozens of scattered windows across multiple virtual 4K desktops piled up over the course of multiple weeks. Having multiple columns of very tall code panels in one 4K editor window is very nice when I need it.

</comment></comment></comment><comment><USER30> I've tried them but far prefer running triple-head setups (since the days of Xfree and CRTs). Triple-head is pretty easy these days and gives you one central monitor plus one either side to chuck windows onto. Current set-up is 3xDell U2715H for a total of (2560*3)x1440 (and 10 workspaces).

If you are going wide, consider vertical resolution/vertical size as well (to minimise swivelling side to side).

</comment><comment><USER31> I use a 32" 4K monitor (LG UltraFine 32UL950-W) directly in front (landscape), and an identical 32" 4K monitor to the right (portrait) off a rMBP 2016, which gives me the best of both worlds. (Both running Retina mode at logical 1900x1080.)

The landscape monitor is for the usual tasks, and the portrait monitor for coding (100 visible code lines in 15pt Operator Mono in VScode).

A fantastic combination.

<comment><USER32> By running 2 x 4K screens, you have a multiple of MP (megapixels) compared to the UW fans in this thread who are essentially just running two mid-2000s resolution screens without a seam — I don't get it.

If monitors were sold by MP like cameras, all this 'resolution' stuff would stop confusing buyers.

<comment><USER31> I should have expanded my answer a bit and said that I had tried some UW screens, and they didn't have the vertical dimensions that the 4K screens have, even in landscape mode.

Thus my hybrid solution.

</comment></comment></comment><comment><USER33> At work I have one of the dell curved ultra wide monitors. ([https://amzn.to/36tH96T](https://amzn.to/36tH96T)). Love it.

I used to have multiple monitors, but many years ago I made the decision that it works better for me to completely control windowing concerns in software. (I use the i3 tiling manager for this.)

I have seen no reason to change.

<comment><USER34> This is an Amazon affiliate link and the author will earn kickbacks if you make purchases after clicking that link.

</comment></comment><comment><USER35> I don't use an ultrawide* but if you're on Windows and get sick of having to move the mouse cursor all the way across the screen then I can recommend getting DisplayFusion and enabling the "Wrap mouse cursor around left/right monitor edges" function.

*: My setup is two 27" monitors next to each other: one in portrait mode and one landscape mode.

</comment><comment><USER36> All the "ultrawide" monitors I've seen are just cropped 4k or 5k screens. Having used full-size versions (3840x2160@32" and 7680x4320@32") I'd never voluntarily give up the vertical space.

If you can find yourself a good deal on a 16:9 27-32" 4k screen, you'll appreciate the extra usable space.

<comment><USER32> > _7680x4320@32_

Any models that you like? That's 33 megapixels, fantastic!

<comment><USER36> As far as I know Dell is still the only game in town with the UP3218K. You'll want to run it scaled though for it to be usable (I use 150% or 200%), and I've only seen it work on PC. Maybe the new Mac Pro can handle it?

</comment></comment></comment><comment><USER37> I'm using a Dell U3419w (34 inch ultra wide).

I'm a web dev, I love it, it is effectively windows at a time. It helps that there is a built in KVM, and it works great as a USB hub with USB-C.

The software to manage window placement is extremely helpful as well.

I go to work with a dual monitor setup and am kinda underwhelmed / annoyed.

</comment><comment><USER38> I've used one a handful of times and if my company ever gives me an option to switch, I would in a heartbeat for one reason alone... merge-conflicts!

At least for intellij, merge conflicts get resolved in a three screen mode, and ultrawide monitors handles them in a way that dual monitor, or normal aspect ratios can't compare.

</comment><comment> X-Istence I have a Dell 34" UltraWide curved and I love it. I upgraded from two monitors to a single UltraWide and not having a bezel is amazing, and the slight curve helps because my eyes don't need to refocus as I move from one corner to the other when looking at it. It has reduced my eye strain tremendously.

</comment><comment><USER39> I use a 34" 21:9 Dell monitor at work and I love it. As other have mentioned, you can get two super wide or three reasonable windows side-by-side, which is great. And I like the option to have a super wide terminal for the overly- verbose Java console output I get to debug.

</comment><comment><USER40> I've got the LG 5k2k 34".

It's great for what I use it for, mostly software development. Only issue I have is that occasionally MacOS decides it can't see it or won't use the full resolution and I have to do a bit of plugging and unplugging.

I might get a smaller 4k monitor on the side. I really value a lot of pixels.

</comment><comment><USER41> Advantage of multiple monitors: you can turn one 90 degrees if you work a lot with vertical documents.

</comment><comment><USER42> I switched to an ultrawide and i3 window manager at the same time, and it's been a game changer. I can't imagine going back to two side-by-side monitors. Being able to resize windows and not be restricted by the screen boundary is the real game changer for me.

<comment><USER43> I've been incrementally tweaking my desktop setup for a decade, and it's always nice to look back and see how much more productive I am than N years ago.

But I'm shocked at what a quantum leap in productivity switching to i3wm was, with an upfront cost that's actually pretty low.

The last piece of my desktop usage that isn't controllable and amenable to incremental improvements is the browser. This is unfortunately a pretty large chunk of my recreational use, so my next mini-projects are probably going to be around investing in getting more familiar with extensions.

</comment></comment><comment><USER44> The only reason I wouldn't recommend it is that it becomes a necessity.

I can no longer code on my laptop to save my life, after running a stacked dual 34" \+ 29" UW setup.

</comment><comment><USER45> Absolutely love it. For Mac OS - spectacle or magnet are a must for arranging windows though.

</comment><comment><USER46> I had the option at work to do either two monitors or one ultrawide. I took the ultrawide, and have never regretted it. You have to use window organization software to use it effectively. I use Spectacle for Mac, it does the job.

</comment><comment><USER47> I use a single 42.5" LG 4k monitor. Never use the full width or height except for watching media. Works fine.

At the office I use a 27" 4k monitor with the 15" MacbookPro off to the side for Slack. Also fine.

</comment><comment><USER48> I have an LG 29", 2560x1080, flat monitor.

It's great for having two full windows side to side (e.g. Firefox and a Terminal), and I love it in my sim racing games, the extra field of view helps a lot with immersion.

<comment><USER49> I have the same monitor, use it with my laptop for developing, and it's really nice - I can keep Slack, documentation, and sometimes a terminal open on the 29" while I use my laptop screen for VSCode. Definitely improves my efficiency.

</comment></comment><comment><USER50> I have two monitors, one of them ultrawide.

The UW is great. I am getting a second one. It is just more screen real estate and makes it easier to work off of, especially if you type and have research open at the same time.

</comment><comment><USER51> I have a Dell U3818DW (38' 3840x1600 curved) and a Dell U2718Q (27" 3840x2160). I love them. They are big enough that I don't need to wear glasses (I'm older).

</comment><comment><USER52> I have a 49" with a native Res of 5120x1440 and can't use it with my MacBook Pro on MacOS.

Works fine in Windows but can't go past 4096x1440@70hz in MacOS...

<comment><USER12> Get switchres.. you can lower the refresh until it displays the desired resolution.

</comment></comment><comment><USER53> i prefer ultrawides , and not too big ones, as i think sitting in front of many monitors too many hours gives me headache.

I do have an issue with wobbling though. i dont understand why they dont make an ultawide with two supports

</comment><comment><USER54> I use 3440x1440 with 2560x1440 on each side.

By day this is a productivity powerhouse, currently Ubuntu 19.10 with an extremely minimal i3 desktop.

I use the left monitor for terminals and the ultrawide normally the entire expanse for my work in sublime text - on my font settings, I can get five panes of 80-col files side by side. The right monitor is Chrome and F12 for whatever I'm building.

I love my ultrawide. I was very hesitant at first and thought I may dislike it but it actually feels like I want an even larger expanse now! It works well for me, I know some don't like it and I can see why. Part of why it works so well for me I think is my use of i3 which makes it really easy to fully utilise all the space.

And part 2 of the above... by night it's running Steam on Windows 10 and it's absolutely fantastic for gaming, especially the genre I lean towards (driving/vehicle simulation). Since NVIDIA still don't allow mixed resolution surround, and I want ultrawide for work, ultrAwide gaming was a necessity which turned out to be pretty fantastic. Games like ETS2, ATS and Assetto Corsa feel that bit more immersive with the extra windscreen space. The monitor fills a good part of my vision and as I have trackir too, it's really quite immersive overall.

Brands or models - Mine is the AOC U3477PQU which was extremely popular but is now sadly discontinued with no replacement. No bad word to say about it. I'm actually planning to buy another ultrawide soon and mount it vertically above the current one; I may end up getting a used U3477PQU again (AOC don't seem to currently make any non-gaming ultrawides which is odd seeing how many they sold).

So with AOC gone, LG are basically the market leaders and supply panels to many others (AOC included I think) and Dell are also high-end. I know Samsung and Iiyama have some compelling value options at the lower end of the market.

</comment><comment><USER55> I went a different way and bought a 42" 4K display¹ (that's roughly the same PPI as 27" @1440p, so 100% zoom on Windows or Linux is just fine, no UI scaling nonsense).

So basically I have 42 inches (107 cm) worth of diagonal in front of me:

Height: 20.84" (≈53 cm); Width: 37.05" (≈94 cm); PPI: 103.64 (≈41 pixel/cm).

This gives me 476x118 lines (476 = _5.95_ × 80 chars!) in full-screen terminal using small-enough fonts² (no reading difficulty here, productivity/comfort > all). Key thing being, _vertical_ space versus a much shorter ultrawide (but about as much horizontal real estate). I think it matters a lot for coders, sysadmins, people who look at text (code, logs), long lists and tables in general.

I must confess that I feel slightly constrained by this monster in a way I hadn't anticipated: whereas real estate is never much of an issue, what I'd call "lack of separation of concerns" emerges: most Desktop Environments are not designed to manage several spaces, at best you get quick quarter-screen resizing for a window but that's weak when you have room for almost 4×1000 pixels horizontally (and more than 2000 horizontal). Remember, this isn't like your typical laptop at 4K: you _really_ have all those pixels to work with at 100% scaling.

So you'd want more avanced features, and moving to e.g. i3 (Linux DE, or rather WM) begins to make a lot of sense.

The software is necessary to managing all that real estate, and it's a little bit of a desert because we haven't really moved to the "wall of screens", "cover my field of view" paradigm just yet. If you like tinkering and use Linux you probably can get 80-99% of the way there though, depending on how demanding you are.

____

But beyond that I think I'll eventually extend this setup to a 3-screen config, with two side 24" displays in portrait mode (which at 1080p unscaled, or 1440p scaled by 1.25, yields almost the exact same PPI as the middle 42.5" juggernaut). Something like that, with _either_ 2×B _or_ 2×C for obvious symmetry:

        ┌───┬───────┬───┐ A: 2160p 100%, PPI 103.64
        │24"│  42"  │24"│ B: 1080p 100%, PPI  91.79
        │ B │   A   │ C │ C: 1440p 125%, PPI  97.91
        └───┴───────┴───┘    (C = 1152×2048 usable)

This would allow me to put things "aside" literally so — monitoring and tracking, ref docs/notes, previews... Things I'd rather not move or rarely so.

I would never trade my uninterrupted 42" for the little convenience of optional separation, but I'm definitely considering adding this to that.

I strongly recommend you look at this option because it's made me virtually unobstructed by anything display-related since I've had it (small thing: I wish it had more DP/mDP inputs).

A smaller version of this setup has a 37" landscape in the middle and 2x21" portaits on the sides.

[1]: Dell P4317Q with up to 4 simultaneous 1080p inputs [https://www.monitornerds.com/dell-p4317q-review/](https://www.monitornerds.com/dell-p4317q-review/)

[2]: Adobe Source Code Pro 9pt, which at 100% with forced 104 DPI to fit the display yields a pretty legible font size. I do most web browsing at 100% or even sometimes less for density.</comment>


Phrases you can touch-type using just your left hand - <AUTHOR> http://www.tbray.org/ongoing/When/200x/2009/10/19/Left-Handed

<comment><USER2> When I was first learning to program, I spent a lot of time typing in hexdumps of programs into my C64 from an early computer mag... Byte, maybe, or even Dr Dobbs. I used my left hand to keep my place in the listing, and my right hand to key in each line of hex and the checksum for that line. (Anyone else remember this?)

Anyway, I got very good at typing with just my right hand, and I can still do it pretty well. (I'm really glad I learned proper touch typing in High School, though.)

<comment><USER3> There arev ariants of Dvorak for typing with only your left or right hand.

See [http://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard#One-...](http://en.wikipedia.org/wiki/Dvorak_Simplified_Keyboard#One- handed_versions)

</comment></comment><comment><USER4>
        grep -i '^[qwertasdfgzxcv]*$' /usr/share/dict/american-english  | shuf | less

lots of good ideas.

</comment><comment><USER5> i realized , i can type my username just by my left hand ! anybody else's username like mine ? :-)

<comment><USER6> Strictly speaking, no, but if pressed I can type both my username _and_ password with one hand tied behind my back.

<comment><USER3> Do you type with the tied hand?

</comment></comment></comment><comment><USER7> wrong, you can't touch type the first one. it has an exclamation point.

<comment><USER8> You can't shift-1 with your left hand?

!!!</comment></comment>


A 1:60-Scale Boeing 777 Built Entirely from Paper Manilla Folders - <AUTHOR> http://www.thisiscolossal.com/2014/01/paper-bowing-airplane/?hn

<comment><USER2> He also has a series of videos on his youtube detailing the painting and build: [https://www.youtube.com/user/lucaiaconistewart/videos](https://www.youtube.com/user/lucaiaconistewart/videos)</comment>


From Silicon Alley to Palermo Valley: Outsourcing to Argentina - <AUTHOR> http://foundersblock.com/articles/from-silicon-alley-to-palermo-valley-outsourcing-to-argentina/

<comment><USER2> The article is kind of an infomercial, but I hope the outsourcing trend continues :)

As an Uruguayan, I believe that both Argentina and Uruguay have well-educated middle class with decent knowledge of English, reasonably good universities with high standards (if you hire a Computer Engineer from a local university I can guarantee that he's a survivor and a good learner at the very least), and while local standard of living is more expensive than India, a below-average US wage is a princely sum here (I make U$ 1.200 after taxes which is U$ 2400 before taxes).

Local governments heavily encourage software development, so it's mostly tax free for now, though employment as a full-time employee is still a bureaucratic nightmare (you're much better off hiring someone as a contractor or independant firm).</comment>


Java Is Unsound: The Industry Perspective - <AUTHOR> https://dev.to/rosstate/java-is-unsound-the-industry-perspective <comment><USER2> The industry perspective is that nobody cares (and rightly so).

I was at the conference where this was presented. The paper is terrifically written, and it's good that someone is investigating this.

That being said, it's just not that big of a deal. In practice, this will never be a problem for anyone writing Java.

The Java wildcard system is _insane_ and no-one is trying to build type systems based on these ideas, not even Scala and the new batch of JVM languages (Kotlin, Ceylon). They have their own problems, but this isn't it.

<comment><USER3> Agreed no one in practice will likely ever see this. Ability to compile vs warned about it are two different things. Those that know Java would quickly be aware that a) type erasure is a thing, it allows stuff like this b) even if they wrote some of this their IDE or compiler would generate a ton of warnings. Generally when you have a compiler - you learn to look at the output of it.

<comment><USER4> Generally when your compiler spits out a lot of warnings you learn to ignore them.

</comment></comment></comment><comment><USER5> I tried to rewrite the bug into a simpler example to wrap my mind around it:

        public interface Helper<T extends Number> {
        }

        public static <T extends Number> Number nice(Helper<T> helper, T value) { // (1)
            return value;
        }

        public static <SUB_T> Number naughty(Helper<? super SUB_T> helper, SUB_T value) { // (2)
            return nice(helper, value); // (3)
        }

        public static Number evil(String value) {
            return naughty(null, value); // (4)
        }

From what I understand, the following is happening:

1: Nothing unusual here. Just defining a type parameter with a constraint and referencing another type which happens to have the same constraint.

2: I think this is the actual bug (?) - SUB_T is permitted as the subtype of a constrained type, yet itself is not subject to the constraint. This compiles.

3: The compiler derives T from pattern matching (this is the sole reason why the helper is needed)

T is inferred as the set of hypothetical types that are both subtypes of Number and supertypes of SUB_T.

4: Because SUB_T is unconstrained, we can happily instantiate SUB_T such that the set of hypothetical types is empty (e.g. set it to String).

This does mean there is no way we could create a helper object as no type would satisfy the constraints - but we don't actually need a helper object, so we can simply pass null.

In short, this bug lets the compiler infer a type hierarchy of Number -> T -> SUB_T without ensuring that Number -> SUB_T holds. Usually, that wouldn't get you far as there is no type that could substitute for T - except that you don't need a type because the compiler will accept null even for "impossible" types.

It's interesting to note that the class cast exception occurs in (3), not in (1). From what I know, that is because Java's erasure takes constraints into account - the arguments of nice() become (Helper, Number) after erasure, not (Helper, Object).

<comment><USER6> yes, (2) is the bug. funny that my IDE catches it, but not the compiler!

<comment><USER7> The article mentions that some compilers catch it, but that by doing so they don't comply with the language definition.

</comment></comment></comment><comment><USER8> Interesting that Ross Tate (the author) is an adivisor to the Ceylon and Kotlin teams. When this was brought up before on HN [1], I found that Kotlin handled these type issues. I can't be 100% confident of that though as I did struggle to fully understand the issue.

1\. [https://news.ycombinator.com/item?id=13050491](https://news.ycombinator.com/item?id=13050491)

<comment><USER9> I've been developing in Scala for years, but lately I've really grown sour at the TypeSafe/Lightbend libraries and tools (poorly documented, half- implemented libraries with major breakage on each release with little to no migration documentation).

People like Paul Philips (yes yes, I know he's ranty and rubs people wrong and is kinda intense, but he makes good points) show that you can build a sane language on top of the JVM, but Scala makes a lot of the same concessions and refuses to fix a lot of implementation bugs in favor of backwards comparability and enterprise support.

I wrote Kotlin off originally as a late into the game pull by Jetbrains, but now I really want to take another look at it and see what type of library and JVM support is has.

<comment><USER10> Since Java interop was a #1 priority w/ Kotlin, it has the same library support that Java does. Almost _all_ of the major libraries just work.

Lately bigger players have started to take notice:

[https://spring.io/blog/2017/01/04/introducing-kotlin- support...](https://spring.io/blog/2017/01/04/introducing-kotlin-support-in- spring-framework-5-0)

[https://blog.gradle.org/kotlin-meets-gradle](https://blog.gradle.org/kotlin- meets-gradle)

I'm still not sure where it will end up, but things look pretty good right now.

But wrt Type Erasure, Kotlin doesn't completely get rid of it; but it does offer some ability to retain Types in some generic situations.

</comment></comment></comment><comment><USER11> It's much easier to write robust code in Java - with it's Optional type, and checked exceptions - than in C#.

 _You probably would never write this, and your colleagues would never write this. That reasoning is good to apply in many situations. I in fact do this all the time; it's a huge part of my research agenda. But you have to be careful where you apply it. Soundness is a security guarantee, not a usability concern. What matters is if someone can write this, because then that someone can get around the security measures that people have placed their confidence in and do whatever they would like to do. In the case of soundness, it's the malicious programmer you should be worried, not just you and your friends._

I really hate this attitude. Programming languages should be designed to be safe and strict by default, but with easy outs. I utterly reject the notion that we should design languages first and foremost to protect us from people can't program that well or aren't careful when they write code.

Do we always have to appeal to the lowest common denominator? Empower the developers that care rather than trying to turn this into an unskilled profession.

<comment><USER12> _with it 's Optional type,_

C# has Nullable<T> (aka T?)[0]. I'm not a Java expert, but they appear to be the same (represent a value or a null value, allow you to inspect for the presence of a value or null).

ex:

      int? x = null;
      int y = x ?? 0;
      int z = x.HasValue ? x.Value : 0;
      if(x.HasValue && x.Value == 42){}

C# definitely doesn't have checked exceptions.

edit:

For reference types, as compared to value types, c# has the null coalescing operator

      List<string> y = someList() ?? new List<string>;

and the null conditional operator

      int? length = customers?.Length; // null if customers is null

which are defintely not Optional, but are what I use.

[0] - [https://msdn.microsoft.com/en- us/library/1t3y8s4s.aspx](https://msdn.microsoft.com/en- us/library/1t3y8s4s.aspx)

<comment><USER13> I'm unfamiliar with Java's Optional type, but the .NET type Nullable can only be parameterized over value types. It is there to add the concept of null to value types, not allow you to more precisely characterize the nullability of reference types.

<comment><USER14> Optional in Java is just a library. If you want to to use Optional in C#, there is no reason to believe that that is not possible due to some issue that makes it only available to Java. [https://github.com/louthy/language- ext/tree/master/LanguageE...](https://github.com/louthy/language- ext/tree/master/LanguageExt.Core)

<comment><USER11> And in Java they're in the the standard library. Which is going to go down better - simply using something official that every java library program will already have, or trying to explain to your colleagues why all your methods are returning something defined in this obscure library you added to all your builds?

<comment><USER15> Only since Java 8. The coalesce operator is in c# since the version 3.5 or 4 I think and c# 6 introduced the null conditional operator that, as I said before, is objectively nicer than the verbose Java optional. Before c# 6 I used this simple extension method:

        public static TDest IfNotNull<TSource, TDest>(this TSource obj, Func<TSource, TDest> func)
        {
            return obj != null ? func(obj) : default(TDest);
        }

Or something similar (writing c# code on the iPad before sleeping is not exactly simple), inspired by some blog post ages ago. Just adding these three line of codes in a static class in the solution will enable you to write something like this:

        var id = order.IfNotNull(o => o.Customer).IfNotNull(c => c.Id) ?? "INVALID"

Still not as good as the null check operator but comparable with the Java optional (arguably better from my point of view)

<comment><USER11> How is it better? All you've done is re-implemented mapping over an option. Your C# code is this in Java:

        String id = order.map(o -> o.Customer).map(c -> c.Id).orElse("INVALID");

The Java code is actually shorter and works straight out of the box, so I don't know why you're calling Optionals "verbose".

<comment><USER16> It's not shorter than out-of-the-box c# 6, which would be var id = order?.Customer?.Id ?? "INVALID";

I think that was the point he was making, that it's always been possible, and now is simple.

<comment><USER11> Except that nullable types aren't the same thing as option types, so it's not doing the same thing. Nullables are much weaker than options. You can't do this for instance:

        string? id = "Name";

While you can do stuff like this:

       int x = 0;
       int? y = x;

Again, F# has nullable types and options, and the fact that no one in F# uses nullable types should tell you something.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER8> "So had history been a little different, either with Sun deciding to throw out backwards compatibility after adding generics, or with Sun adding generics into the JVM, or with Java first being released with generics, then this exception would not be thrown"

It returns a ClassCastException because underneath it all, in the Java bytecode the Java compiler stores generics as casts. Therefore it will complain because it can't cast. If they had baked generics in at the beginning of Java then it wouldn't have compiled.

It would be the equivalent of writing String one = 1;

<comment><USER17> > It returns a ClassCastException because underneath it all, in the Java > bytecode the Java compiler stores generics as casts.

Right - the article already says that doesn't it?

> If they had baked generics in at the beginning of Java then it wouldn't have > compiled

Why wouldn't it have compiled if the JVM had generics? It's an error in the design of the type system of the language isn't it? The type system is the same if we have reified generics or erased generics isn't it? And that's where the failure is - not at the JVM level.

<comment><USER18> I agree with Chris, it would be a lot worse if generics were reified in Java because instead of having some spurious ClassCastExceptions, you will get memory corruptions instead.

</comment></comment></comment><comment><USER19> I don't understand how lines 4 and 15 don't get caught by the compiler-- a String cannot extend an Integer?

I'm not even sure how you would be able to write this in Scala without violating rule number 1 of Scala, which is "never write the word null in your code".

<comment><USER20> In the article the author mentions that it's due to the null assignment in the first line of the `coerce` method.

Look for the "Thanks, NULL!" section near the bottom.

<comment><USER9> I wish Java had done more backwards comparability breakage. I wonder if we'd see the same issues if Java eliminated null in exchange for a Option/Maybe style monad and if generic types were saved instead of erased at compile time.

<comment><USER18> Java 9 is not fully compatible with Java 8. So we will soon see first hand if doing more backward compat breakage, for good they told, will be accepted or not. I predict there will be an internet outrage when Java 9 will be out.

</comment></comment></comment></comment><comment><USER21> As a C++ programmer but not a Java programmer, why is it reasonable for Java to consider nonsensical types (where constraints are violated) to be valid but just not instantiatable? Wouldn't it be better to reject the type entirely? Then you couldn't have a null object of the type since the type itself is ill- formed.

<comment><USER22> For C++, one kind of nonsensical types is abominable function types, which are bare functions with cv-qualifiers [1] [2].

[1] [http://www.open- std.org/jtc1/sc22/wg21/docs/papers/2015/p017...](http://www.open- std.org/jtc1/sc22/wg21/docs/papers/2015/p0172r0.html)

[2] [https://news.ycombinator.com/item?id=10935171](https://news.ycombinator.com/item?id=10935171)

<comment><USER21> That's a rather different issue. Abominable types are annoying and mostly worthless, but there's nothing inherently wrong with code containing a type variable that refers to the type. Java's screwy generic instantiations are types that violate constraints by merely being named.

I'm not saying that C++'s type system is great. I'm just saying that Java's problem mystifies me.

</comment></comment></comment><comment><USER23> I would not call this "industry perspective". Java type system is good enough for "industrial use".

Most problems described in article are not for backward compatibility. But because java at runtime (JVM) is dynamically typed (Java compiler is statically typed). You can do much nastier tricks with reflection.

Scala is not much better, I wrote some examples: [http://www.mapdb.org/blog/scala_has_weakly_typed_syntax/](http://www.mapdb.org/blog/scala_has_weakly_typed_syntax/)

</comment><comment><USER24> So... you can assign null to a variable whose type is illegal to instantiate (but not to define), and code which has that variable in scope which will compile with the assumption that the type _can_ be instantiated.

>Is it safe for Foo<String> to be a valid type?

Wrong question. Is it useful for Foo<String> to be a valid type? The answer is probably no. So why allow it? The below example does not come close to explaining why this should be a language feature.

</comment><comment><USER25> The article makes multiple misleading claims.

First, it calls unsound the fact that an exception gets thrown in the shown code. There is no data security issue, no possible JVM escape, no type system failure. You can get the same cast exception with straight-forward code. The claim of unsoundness is merely based on the fact that the problem is obfuscated. Using unsound here is misleading.

Second, the whole point relies on implicit type relations that are not checked at compile-time when nullptr is involved. Certainly, it's a weakness in the specification that can cause suprising run-time exceptions, but it's not a hole in the type system.

Third, it makes claim that the JVM was saved by its early choice of backward compatibility. This is a bad habit that I've seen elsewhere: making claim about unspecified, unknown alternate histories. In this case, had generic not erased type, then assignment from nullptr would not work. Surely, the nullptr would have acquired typed alternative (nullptr<T>: nullptr<String>, nullptr<Integer> ...) which would have letthe compiler type-check properly and catch the problem at compile-time.

<comment><USER26> Your first point runs counter to my understanding of what the author said. Specifically:

"Here's our "true" unsoundness example that has been making the rounds most recently. It assigns an Integer instance to a String variable. According to the Java specification, this program is well-typed, and according to the Java specification it should execute without exception (unlike the aforementioned backdoors) and actually assign the Integer instance to the String variable, violating the intended behavior of well-typed programs. Thus it illustrates that Java's type system is unsound."

That is, the author's unsoundness claim is independent of the class cast exception.

On your second point, you may be in violent agreement with the author. What is the difference between "a weakness in the specification" and being "unsound"? The author's definition is that this is an _unintentional_ hole in the type system, unlike the intentional ones he outlined.

</comment></comment><comment><USER27> The real implication here is that Java behaves funny because of backwards compatibility. We're quite a distance away from < jdk1.5 days... What's the weather like to update the Java memory model or type system to take care of these obscure cases? We managed to add a new opcode to the JVM (invokeDynamic) and the world survived!

<comment><USER18> It's the opposite actually. Here the erasure is a good thing otherwise the bug described in the blog will have break the VM. The type system is broken because it supposes you have a type that exists and in the code you send null instead. If generics were in the VM, this kind of bug would have break the VM but 'thanks' to the way generics are handled in order to be backward compatible, a cast is inserted so this bug in the type system do not break the VM.

</comment></comment><comment><USER6> This seems to be a set of examples that don't work, rather than a set of examples that prove a point. For example:

        interface IFoo<T>  { Number foo(T t);  }

        class Foo<T extends Number> implements IFoo<T> {
            public Number foo(T t) { return t; }
        }

        Number bar(IFoo<String> foos) { return foos.foo("Nan"); }

This implies that something bad is going on. But the class in the middle is a red herring. It is not used in this example, nor can it be used as an argument to the `bar` method. Try instantiating a Foo<String> and it wont work. Try instantiating a Foo<Integer> and then passing that to bar(), which requires an IFoo<String>. Both are _compile_ time errors.

By all means claim, correctly, that support of unchecked code and raw types means that the type system is not "sound", but the incorrect examples undermine the claim that this is a problem. (I don't personally think that its a problem, and the fact that someone claiming otherwise can only provide examples that fail to prove that its a problem isn't terribly convincing. But then I grew up with 6502 ASM, which had a fairly limited type system).

<comment><USER28> This example is not to show that Java is unsound. It's to teach you the difference between types that are invalid and types that would be unsafe but are allowed because you can never instantiate one.

Like you note:

> Try instantiating a Foo<Integer> and then passing that to bar(), which > requires an IFoo<String>.

That's what Ross is trying to get you to see. He's saying that Java does _not_ have to make the declaration of IFoo<T> an error because it can rely on the fact that your later instantiation of it with <String> will be an error instead.

As long as the bad code gets flagged as an error _somehow_ before it gets used, you're safe.

The actual unsoundness bug is the "class Unsound" example in Josh Bloch's tweet. What it shows was that you _can 't_ safely rely on "we'll flag an error when you create an instance of this type, so we don't need to flag an error in its declaration." Because you can assign _null_ to be an instance of the type and then you sidestep the later error.

<comment><USER6> I disagree.

class Foo<T extends Number> implements IFoo<T> {}

Does not implement an unconstrained T. It implements "T extends Number". When the T appears in an implements, its not declaring a new type. You can't do, for example

      class Foo implements IFoo<T> {}
      java: cannot find symbol T

The mistake is believing that the T's, in the example above, are in any way related. It would be more appropriate to write:

      interface Foo<TUnconstrained> {}
      class Foo<TExtendsNumber extends Number> implements IFoo<TExtendsNumber> {...}

And then it becomes clear that the foos in bar will never be a Foo, because Foo _does not implement_ IFoo<String> and never will. Yes you can nuke it unchecked code. No, I don't have a problem with that. But the example given is not a useful example.

And this example is in response to the previous one where he asks "Is this code safe? .. your gut instinct would say this is unsafe". No. My gut instinct is that it _would not compile_. And indeed:

      java: type argument java.lang.String is not within bounds of type-variable T

<comment><USER28> > I disagree.

I don't know what you're disagreeing with.

> And then it becomes clear that the foos in bar will never be a Foo, because > Foo does not implement IFoo<String> and never will.

The statement "Foo does not implement IFoo<String>" is not meaningful. "Foo" is not a type, it's a type constructor. To refer to a type, you need to say Foo _of what_. And it is the case that Foo<String> implements IFoo<String>.

Consider:

        interface IFoo<TUnconstrained> {
          Number foo(TUnconstrained t);
        }

        void useFoo(IFoo<String> foo) {
          Number n = foo.foo("not a number");
        }

This code compiles fine. Add this:

        class Foo<TExtendsNumber extends Number> implements IFoo<TExtendsNumber> {
          public Number foo(TExtendsNumber t) { return t; }
        }

It still compiles fine. This is exactly what the author is saying. The reason it is fine for the compiler to permit the above code is because it is relying on the fact that you will not be able to instantiate Foo<String>.

This is one half of the puzzle of the actual unsoundness example. The other half is that you can then sidestep _that_ restriction using a wildcard to define a type that hypothetically meets the required bound even though no such real type exists.

That would still be safe, since you've never be able to initialize that variable since no value of that type is possible. Except that Java lets you initialize it with null.

</comment></comment></comment></comment><comment><USER29> > Consequently, all the proofs were correct, but they failed to model Java > correctly and missed this bug.

David Byrne repeating "Same as it ever was" comes to mind ... ( [https://www.youtube.com/watch?v=I1wg1DNHbNU](https://www.youtube.com/watch?v=I1wg1DNHbNU) )

</comment><comment><USER30> How many ClassCastExceptions or ArrayStoreExceptions are people seeing?

Meanwhile, javascript is winning.

From a practical perspective, static type systems have proven useful for tooling: to help us with code completion and refactoring. Beyond that, they appear mainly to hurt developer productivity.</comment>


Hacking websites via third-party JavaScript libraries - <AUTHOR> https://dmsec.io/hacking-thousands-of-websites-via-third-party-javascript-libraries/ <comment><USER2> That's a risk every time you use a CDN. We used a CDN that f-ed up JS versions, breaking sites, had downtime, breaking sites... when ever you do use a CDN, be aware of everything that could go wrong, which is a lot... On the other hand, id you add hashes to the script references you load, you are a lot more secure, check out [https://developer.mozilla.org/en- US/docs/Web/Security/Subres...](https://developer.mozilla.org/en- US/docs/Web/Security/Subresource_Integrity) if you use a CDN and would like to do so securely...

<comment><USER3> Please excuse me if this is a dumb question, because my primary job isn't in web development, but what is really the benefit of using javascript code from a CDN rather than hosting it yourself? The way I see it, you're opening yourself up for massive potential trouble by essentially giving someone else a free pass on running whatever code they wish on your website, and you're giving up this privilege for what? I honestly don't understand, but it's so popular that I'm assuming I've missed something.

<comment><USER4> Hosting javascript from a CDN is useful for a few things

a) seperates static hostic (js/css/images) from dynamic hosting, which require different tuning and traditionally may run better on separate machines

b) you used to get some parellism benefit from multiple hostnames, that might be gone with http/2, but then you may not want head of lime blocking interacting between html and css/js

c) a good CDN will get your js/css/images to your users faster than if they got them directly from your origin servers, if your assets are of significant enough size to overcome the overhead of connecting to the CDN, and the chance that the CDN has a cache miss (depends on usage). A good CDN is using geo aware DNS and/or anycast to get clients to a datacenter that's near to them, and chances are your origins are only in one to three locations. For one site I worked on, when we did a redesign that doubled the page weight, but also moved serving everything behind a CDN, the page load time ended up about the same, so the CDN basically let us double our page weight for free (I would have preferred that we just keep the page smaller and get a faster site, but I don't get to make those decisions)

d) some people claim there's a reasonable chance of browser caching if you use a public CDN path, although personally, I expect that's very small -- there are so many public CDNs and so many versions of all the libraries and most browsers have fairly small local caches.

</comment></comment></comment><comment><USER5> > _The Tealium iQ Tag Management System service is used by many companies to > organize tags on their websites._

Tag managers are the worst. They shouldn't even exist. When a website uses a tag manager, it means the web devs have been forced to give marketing and every other department a backdoor to insert whatever vile abominations they want.

</comment><comment><USER6> > Each time a new table was generated, a new PHP file was created on the > server. Using a hole in filtering of the input parameters for creating the > PHP file, I was able to reproduce an RCE attack: a malicious request > injected arbitrary PHP code into the generated file.

So this has nothing to do with the third party JS library itself, but with how the website's backend stored the data generated by the frontend script. The developer could probably reproduce the hack with postman and doesn't need the CDN hosted library at all.

</comment><comment><USER7> A few ways out of these are:

\- don't eval on the server side (this is a bad idea most of the time anyway);

\- serve js bundles from your own domain and set an appropriate content security policy;

These hacks won't work then.

<comment><USER8> The charting vulnerability discussed in the article and found to be introducing vulnerabilities in 90 crypto coin sites remains 100% effective if you never eval server side and only serve bundles from your own domain with appropriate content security policy. Worse, now that the bug has been fixed in the vendor's distribution, your customers would still be at risk if you were self hosting the old files. There are no simple solutions to securing large complex systems. It's simply hard and takes lots of work, and you will almost certainly still be vulnerable in the end. That's why physical locks are rated in terms of time for attackers to open not inability of attackers to open.

</comment></comment><comment><USER9> While I think SRI is a good tool to counter CDNs (with the correct deploying strategy, human-supervised semi-automatized SRI generation shall become trivial), there is a fundamental flaw with "compiled" aka obfuscated/minimized javascript code: How do you, as an author, even know that it doesn't contain malicious code in the first place? That's the fundamental problem of using software written by other people: Except you can afford expensive code audits, you never know. I expect any security-related company (like Banks) to do these source code audits. But I doubt they do it.

<comment><USER8> SRI: [https://developer.mozilla.org/en- US/docs/Web/Security/Subres...](https://developer.mozilla.org/en- US/docs/Web/Security/Subresource_Integrity)

</comment></comment><comment><USER10> Minimize JS use, serve the JS you use only from your own domains, run high security apps on dedicated domains with less JS and other external shit than your public marketing site, and use CSP.

I'd probably trust a single CDN (like cloudflare) with my own copies of all things I include more than I'd want to serve directly but use code from lots of different sources, but for something incredibly high security, I'd want end users to be talking directly to a secure server (maybe with tcp/etc. layer proxies for ddos resistance and flow-level monitoring, but without decrypting).

</comment><comment><USER11> In the first example, this guy goes and pops a (web)shell on Datatables.net. There's no security policy, no bounty program, etc. for this site or its owner[2]. Generally I don't believe it's a good idea to go pwning businesses' servers that don't give you some sort of permission to test. That's some seriously dangerous business.

[2] [https://sprymedia.co.uk/](https://sprymedia.co.uk/)

</comment><comment><USER12> The fact that this was possible is a testament that web devs really have no concept of due diligence. Sad.

Imagine if running a native app on your computer would load random DLLs from servers. It boggles the mind.

<comment><USER13> Technically applications with auto updates do load "random" DLLs from servers.

I'm pretty sure you can't make a blanket statement like this without discounting a lot of developers who _do_ take security into account when developing. These are just some interesting holes that were reported.

Is all your code perfect?

</comment></comment><comment><USER14> I'd really like to see a web where developers stop `npm install`ing tons of dependencies, I really would!

<comment><USER15> Keep the DevOps Mindset but get rid of DevOps as a thing where Devs are allowed to control everything that goes into production without a technical argument (the argument has been replaced by test-cases). We need to start having hard discussion again between devs (the agents of change) and ops (the protectors of the realm). Maybe not for every case but

Note: having seen terribly rigid processes I'm very much an advocate for DevOps and welcomed this way of working. I think we threw out the baby with the bathwater when we embraced DevOps. A site that allows what is mentioned in this article doesn't have a functioning Operations unit.

<comment><USER16> DevOps is not about letting devs control everything that goes into production. There is a much deeper problem with npm and the bloat driven web development. The amount of JS code an average website had more than a rich client implementation would be. The generic argument for web used to be that the resulting size of the web site is smaller than the rich client. This is not true anymore.

</comment></comment></comment><comment> King-Aaron Doesn't surprise me that WA.gov.au is full of vulnerabilities.

</comment><comment><USER15> SRI is such a cool idea (in theory) but the approach fails in practice. Also very few sites maintain a solid Content Security Policy (CSP). What's the point of all these controls/tools when nobody uses them?

<comment><USER17> I would suspect that ads make it difficult if not impossible to write a good CSP. It's also probably much easier to create a good CSP if you start with it, and much harder and likely to break unexpectedly if you try to add it retroactively on an existing site.

I also found that some modern tooling for web apps doesn't seem to be built with CSPs in mind. For example CSS styling in JS like React Styled Components, I'm not sure it's even possible to create a CSP that covers CSS in this case.

<comment><USER18> It is, but often not supported out of the box. You will need to extract any css during the build into separately served files. Also it's a pain during development. But it's possible.

</comment></comment></comment><comment><USER19> I've come to the conclusion that the way to secure your website from third party JavaScript is to monitor everything happening on your site: [https://enchantedsecurity.com/](https://enchantedsecurity.com/)

These third party libraries are a necessary part of modern websites. It's worth trusting but verifying their security.

<comment><USER13> >Add Enchanted Security's JavaScript to your website to prevent data exfiltration attacks, protecting passwords, credit cards, and other sensitive information.

>Install Enchanted Security's tamper-resistant JavaScript snippet on your site. The inline snippet is designed to be small, adding only a few milliseconds to load time, and does not require active configuration on your end.

There's a lot of marketing copy on your site, but it doesn't really tell me what it's really doing, or even how Enchanted Security itself is secured.

<comment><USER19> That's because the website's main purpose is marketing, not explaining inner workings. The site explains four steps and you mentioned only the first step, installing it: [https://enchantedsecurity.com/how-it- works](https://enchantedsecurity.com/how-it-works)

If anyone wants to know more they can schedule a private demo.</comment></comment></comment>


Super AMOLED displays help Samsung keep technological leadership - <AUTHOR> https://reportagram.net/tech/1283-marketing-warfare-how-super-amoled-displays-help-samsung-keep-technological-leadership.html <comment><AUTHOR> I also have a yellowish white problem with my One Plus 5, on default display settings my screen shows a bit yellowish color on white background or when I compare my phone with other IPS display phones my One Plus 5 shows a little yellowish display do you know why it's happening to my One Plus 5 or it's because of optic AMOLED nature that shows true accurate colors.</comment>


An end to the Google bonus fairytale?  - <AUTHOR> http://news.cnet.com/8301-1023_3-10128455-93.html?part=rss&subj=news&tag=2547-1_3-0-20 <comment><USER2> "fairytale-like cash bonuses on the north side of $20,000" ??

That's what? Around 20%? Hardly "fairytale-like". The last place I worked was around 30%, and the place I currently work has an _average_ (well, had until this year) of 40%.

</comment><comment><USER3> If you follow through to the comments on the original Valleywag article, you'll see that this article's confusing two different bonuses. The Google holiday bonus has always been about $1000 cash, so it's a cut of "only" 60% or so. Not great, but better than the pink slips many Yahoo employees are getting. The Google performance bonuses don't come out until March or so, so nobody will know how much they've been cut until then.</comment>


Show HN: Luxe Projects – Marketplace to purchase high quality side-projects - <AUTHOR> https://luxeprojects.site <comment><AUTHOR> For more info on this project visit [https://luxeprojects.site/faq](https://luxeprojects.site/faq) :) Thanks for checking this out!</comment>


The 100th Meridian, Where the Great Plains Begin, May Be Shifting - <AUTHOR> http://www.ldeo.columbia.edu/news-events/100th-meridian-where-great-plains-begin-may-be-shifting <comment><USER2> I live on this line (Oklahoma). We go through feast or famine with water here and have for 100s of years.

Here's a nice graph from OWRB (old 2011 data but still shows the swings): [https://i.imgur.com/vLA1hAk.png](https://i.imgur.com/vLA1hAk.png)

Source: (slow loading) [http://www.owrb.ok.gov/supply/drought/pdf_dro/DroughtFactShe...](http://www.owrb.ok.gov/supply/drought/pdf_dro/DroughtFactSheet2011.pdf)

It's on page 2.

<comment><USER3> The minimum seems to be ~19 inches which is quite a bit of rain. Around 1/2 the US averages less than that: [http://www.eldoradocountyweather.com/climate/US%20Climate%20...](http://www.eldoradocountyweather.com/climate/US%20Climate%20Maps/Lower%2048%20States/Precipitation/Mean%20Total%20Precipitation/Gallery/mean- total-precipitation.html)

<comment><USER2> This is the state average.

Typically the western part of the state (west of the 100th Meridian) is dry as a bone and in constant drought, while the eastern side is flush with water. Along the 100th we get both extremes.

This summarizes it pretty much perfectly: [http://droughtmonitor.unl.edu/CurrentMap/StateDroughtMonitor...](http://droughtmonitor.unl.edu/CurrentMap/StateDroughtMonitor.aspx?OK)

<comment><USER4> I'm not well versed in that kind of thing, but doesn't "drought" just mean with respect to the average? In other words, what counts for a drought in western Oregon is different from a drought in southern Arizona, right?

<comment><USER5> Yes, drought is for a region based on its averages. One problem is droughts and wet spells can happen on periods with length of a decade.

</comment></comment></comment></comment></comment><comment><USER6> You may also be interested in the Ogallala aquifer ([https://en.wikipedia.org/wiki/Ogallala_Aquifer](https://en.wikipedia.org/wiki/Ogallala_Aquifer)), which is kind of important to agriculture west of the 100th ([https://www.scientificamerican.com/article/the-ogallala- aqui...](https://www.scientificamerican.com/article/the-ogallala-aquifer/)).

<comment><USER7> If you're interested in some newer data for the High Plains Aquifer (AKA Ogallala Aquifer), try this:

[https://www.usgs.gov/news/usgs-high-plains-aquifer- groundwat...](https://www.usgs.gov/news/usgs-high-plains-aquifer-groundwater- levels-continue-decline)

</comment></comment><comment><USER8> Tipping my hat to the Tragically Hip reference. RIP Gordy.

<comment><USER9> "New Orleans is sinking man and I don't wanna swim".

</comment></comment><comment><USER10> If you'd like to read more about this, I recommend John Wesley Powell's biography: "Beyond the Hundredth Meridian: John Wesley Powell and the Second Opening of the West" [https://amzn.to/2H2v7oZ](https://amzn.to/2H2v7oZ)

<comment><USER11> Another good one (though a bit dated now) is Great Plains by Ian Frazier.

[https://www.amazon.com/Great-Plains-Ian- Frazier/dp/031227850...](https://www.amazon.com/Great-Plains-Ian- Frazier/dp/0312278500)

</comment></comment><comment><USER12> Maybe it's just me, but that headline sounds as if the 100th Meridian, rather than where the Great Plains begin, is shifting.

Perhaps a better headline would be "The Great Plains, which began at the 100 Meridian, may be shifting".

<comment><USER13> It's a play on a song lyric

[https://g.co/kgs/AgyHpo](https://g.co/kgs/AgyHpo)

<comment><USER12> Ah, I see. Unfortunately, I'm not familiar with that part of (edit: North) American culture.

<comment><USER14> More of a Canadian culture reference, or at least more widely recognized in Canada.

</comment></comment></comment></comment><comment><USER15> What is it about the climate change weather patterns that's pushing the line East? It's not like the Rockies have gotten taller. That is, a storm moving east is depleted when it hits the Rockies. That leaves a desert to the East. Are there less storms? Faster moving storms? Both?

<comment><USER16> "In the northern plains, rainfall has not changed much, but temperatures are going up, increasing evaporation from the soil. Further south, concurrent shifts in wind patterns are in fact causing less rain to fall. Either way, this tends to push western aridity eastward." \- the linked article

<comment><USER17> The 100th Meridian coincides almost exactly with the western edge of the Gulf of Mexico. If I understand correctly, moisture comes up from the south, not just from the Rockies. If the wind pattern changes so that more air comes from the west and less from the south, that moisture flow is reduced.

</comment></comment></comment><comment><USER18> Fascinating! It's very interesting to see some real life effects of climate change in the lower 48.

I would love to see some future projections here.

<comment><USER7> There are many more examples:

[https://www.epa.gov/climate-indicators/downloads- indicators-...](https://www.epa.gov/climate-indicators/downloads-indicators- report)

<comment><USER18> Thanks for that link! Never seen that before.

</comment></comment></comment><comment><USER19> I want to emphasize the YouTube video at the bottom of the article: [https://www.youtube.com/watch?v=BCFo0a8V-Ag](https://www.youtube.com/watch?v=BCFo0a8V-Ag)

As soon as I saw the headline, I knew I couldn't let a reference to my favourite band go unmentioned. It is almost criminal how underappreciated the Tragically Hip are as a band.

<comment><USER20> _It is almost criminal how underappreciated the Tragically Hip are as a band._

This statement is somehow perfect.

</comment></comment><comment><USER21>
      Driving down a corduroy road,
      Weeds standing shoulder high
      Ferris wheel is rusting off in the distance
      At the hundredth meridian
      At the hundredth meridian
      At the hundredth meridian
      Where the great plains begin

<comment><USER22> Hello fellow Canadian</comment></comment>


On the Bleeding Edge: Advanced AngularJS Form Validation - <AUTHOR> http://code.realcrowd.com/on-the-bleeding-edge-advanced-angularjs-form-validation/

<comment><USER2> Can someone who is proficient in Angular explain to me why this many attributes are required on the form element itself:

        <form ng-app="LoginApp" ng-controller="LoginController" ng-submit="login()">

This leads to my usual reaction to Angular: I'm sure they've got some things right, and I believe that data binding is the way to go, but holy shit that code is ugly and verbose. I've been using reactive.js [1] lately with Component [2] and its incredibly beautiful by contrast:

        <form data-submit="login">

It uses data attributes, functions are handled for you automatically so you don't have to write the parens all the time, it will fallback to the model automatically if the view doesn't have a certain property. And the view is passed in so you don't need to specify what controller or "app" to search for, which seems way less tightly coupled.

Really it's one of the most beautiful libraries I've ever seen. So why would I ever want to use Angular?

I'm honestly curious since I've heard so many good things about Angular. It seems like they need a few more designers who can code on the team--people who care about the user experience part of API design.

[1]: [https://github.com/component/reactive](https://github.com/component/reactive) [2]: [https://github.com/component/component](https://github.com/component/component)

<comment><USER3> To answer your question, those attributes are not all required on the form element. From the docs on ngApp[1]:

      Use this directive to auto-bootstrap an application. Only
      one ngApp directive can be used per HTML document. The
      directive designates the root of the application and is
      typically placed at the root of the page.

The ngController directive gives behavior to a scope. So, in this example, the behavior of the LoginController is available to everything within the form element. ngController could be placed on a div that encapsulated the form and the result would be the same.

The only thing really _required_ on the form element for this example is the ngSubmit directive. The other two tags can be placed elsewhere.

[1]: [http://docs.angularjs.org/api/ng.directive:ngApp](http://docs.angularjs.org/api/ng.directive:ngApp)</comment></comment>


Ask HN: What do you do before you start writing code? - <AUTHOR> I'm a relatively junior engineer, but recently I've been working on a more complex project than I'm used to.
On a couple of recent occasions, I've written a bunch of code, only to have my colleagues correctly point out some decisions I'd made in writing it that made the code more complicated, and harder to reason about, than necessary (e.g. which logic should belong in which function, or what data structure I should use for something). I'm sure that this has amounted to a lot of wasted time. If I could have foreseen these decisions before writing code, or even just realized while writing code that I was making decisions that I ought to stop and think about, I wouldn't have made these more complicating choices, and wouldn't have had to spend all this time reworking my code.
(Of course, if I can learn a good lesson from this, the time will not have been wasted. Hence this post.)
The thing is: We'd spent significant time planning the structure of this project, with (I'd thought) clear documents and diagrams explaining what components we needed and how they would interact. When I started coding, I felt pretty well prepared, and confident that the thing would basically write itself.
So, HN: What steps do you take before setting out to write code? Are there principles that you use to decide that your plan/design is sufficiently detailed?
And, assuming there will be cases when the plan does not anticipate all design decisions: When you're coding, how do you avoid making decisions that will waste a lot of your time? <comment><USER2> Firstly, time spent learning is not time wasted!

Secondly, the best way to avoid making painful design decisions is... to make them enough times that you instinctively remember them. There aren't many shortcuts to developing that instinct, so take this opportunity to try and generalize your learnings -- what do you recognize now that you didn't see when you started the project? A healthy amount of retrospection will make you a better engineer, and you'll also get better at identifying uncertainties and risks before you start coding.

Lastly, up-front planning and design documents can only get you so far. They're important, sure, but at some point you'll be down in the nitty gritty details, and you'll need to make unanticipated course corrections. As you gain experience you'll start being able to fill in more of those gaps on your own, but until then, you'll want to loop in other engineers more frequently.

One of the qualities of a senior engineer is that they act as a force multiplier for their team. So as a relatively junior engineer, don't be afraid to make use of your senior engineers! They should be there to support you and make you better, beyond just helping you plan out a project. If possible, pair on some of the trickier parts with them, so that you can see how they'd approach the problem and start picking up on things that might not seem so obvious to you right now.

Hope that helps!

</comment><comment><USER3> Over time these small wastes-of-time will decline, as you get more experienced and learn from feedback. But there's also the really big wastes of time: working on wrong thing, and building something with assumption that turns out to be false. The latter has been a problem for me recently, so been working on it by adding step 4 below.

Here's vague model of what I do:

1\. Figure out what's really important to achieve: ask _why_ you're doing something, what the constraints are. Figure out if you really have best solution, maybe there's different way to solve real problem.

2\. Sketch out a design, in my head or in writing depending on complexity.

3\. Figure out riskiest assumptions.

4\. Try to build smallest possible end-to-end proof-of-concept implementation. This will validate or invalidate assumptions, and usually influence design in some way.

5\. Start on real coding.

(If you'd like to learn from mistakes I've made over the years, in design and testing and writing software, I write a weekly email with a mistake and what I learnt from it: [https://softwareclown.com](https://softwareclown.com))

</comment><comment><USER4> there are no such thing of waste of time, except when you delete code. if you have a basic design that code can be used for prototypes. if you have a complex design that code will take your time to handle complex. but if you can't handle all the code you ever write, so the problem is not the code, then you might organize your global assets in a way you can remember how they are organized. but if you are talking about achieving faster your goals then you don't need to code you need lots of people coding and people that can manage a developer team.</comment>


Can someone give me the stats of success of MOOCS? - <AUTHOR>

Would love if someone would point me to the write links about some coding MOOC statistics as I'm not convinced that these services produce actual quality apps. Thanks <comment><USER2> According to [http://docs.scala-lang.org/news/functional-programming- princ...](http://docs.scala-lang.org/news/functional-programming-principles- in-scala-impressions-and-statistics.html), 50 thousand people signed up for scala class, and about 9.5k people finished it successfully.

I've been signing up to some courses in coursera.org, and some classes at the end send out statistics. Another class "Programming Mobile Applications for Android Handheld Systems" recently sent me email that 220k students signed up, and about 7k students will pass it.

So percentage of signups to successes is small compared to college classes, but if you look at '7k' or '9.5k' completions, it's rather impressive.</comment>


Pass JSON data to Golang error using Eris package - <AUTHOR> https://github.com/rotisserie/eris/tree/v0.4.0 <comment><AUTHOR> We created Eris for error handling in our Go services

If you're a Go developer, there's a very high chance you've seen a pkg/errors stack trace. We've used it in all of our Go microservices until recently, and while it has definitely improved the debugging process, we've always wished some things could be better. Specifically, we wanted more readable stack traces in our JSON logs and were disappointed that trace formatting is rigid in pkg/errors. For better or worse, we use global errors extensively and noticed that their stack traces are totally useless (containing lines like "runtime.doInit", etc). It's also clear that pkg/errors is in maintenance mode even though Go 1.13 missed the mark on error handling in our opinion.

Switching over to it in our production code seemed like a risk at first, but there were enough similarities to the pkg/errors interface that we decided to go for it. The feature that worked well for us was flexible error formatting to JSON, which takes most of the guesswork out of finding and fixing bugs. And then, later on, support for global errors was added to make their stack traces useful. We also recently started using Sentry for error monitoring and added that to Eris.

Overall, we're already seeing a benefit in terms of time saved while debugging, and we're glad we made the switch. Has anyone else found good alternatives to pkg/errors?

</comment><comment><USER2> Our developers are using this library in production and have to say that it solves most of our needs. If it had support for As() method it would be great!!</comment>


The ICSI Haystack Panopticon - <AUTHOR> https://www.haystack.mobi/panopticon/index.html <comment><USER2> I thought from the title this would be something about a prison. It would probably be wise to mention in the title that this is for identifying network tracker sites (or the actual intent, if I misunderstood.)

<comment><USER3> The original panopticon was an architectural design about a single point being able to observe all the (prisoners / students / patients) while the observed were uncertain if they were being watched. Therefore they would have to behave all the time.</comment></comment>


UTF-8: The Secret of Character Encoding  - <AUTHOR> http://htmlpurifier.org/docs/enduser-utf8.html <comment><USER2> Okay, by this point in time, I _really_ hope that everyone on HN that needs to know (i.e. all programmers) actually knows about Unicode and UTF-8. Finding the right libraries for the job is pretty googlable. Are all these "UTF-8 is awesome" articles really so relevant?

UTF-8 has been around since 1993 and has been widely used on the web and as standard in most decent operating systems for at least 5 years, so enough already!</comment>