skysight-inc/HackerNews huggingface dataset:
> in a trivial sense, that nuclear waste when stored in a manner that effectively shields it from emitting radiation into the surrounding environment

Why is that trivial? It's how it's actually done. I couldn't care less about the theoretical this or that (that will never actually be done).

It's how it's actually used that matters. And as used today, in the real world, coal produces more radiation than nuclear power.
It depends on who needs who. If you have enough customers that you can afford to avoid haggling with a buyer, then that's great for the seller. If the seller is deciding between no money and some money, then they might have to haggle. Right now, I'm lucky enough that I don't have to haggle when I sell my services. It saves both me and the buyer time, because they know they can't afford me and go move on.
NSA’s Guide on Bluetooth Security
Crosstalk, which covers defense-oriented software development, did a whole issue[1] on this a number of years ago. Now to some extent it's geared towards SEI/CMMI and waterfall crowd, however, even if you don't agree with all the analysis it's still a good read.

[1] http://www.crosstalkonline.org/storage/issue-archives/2006/2...
I find myself thinking more carefully about how data is actually represented in a computer

Such a shame then that the Arduino helpers have managed to conceal that.

On the 8-bit AVR architecture, you can of course just assign your counter variable directly to the memory-mapped pin output register and don't have to deal with them on a per-bit basis. You can even omit the counter altogether and just use the pin output register.
One Man's Quest to Make Business Travel a Lot Less Awful
Ok, here is mine: Prototyper.
- Create a webapp that allows the users to choose their phone model.
- Based on that, generate and allow downloading of a custom app (Android, iOS) for that model.
- The user should be able to customize the software modules for that app and interconnect them, IFTTT-like.

HTH ;-)
I'm not sure this fits but there's google moderator.

You make a topic, people submit questions, people can vote up the questions, people giving talk can answer the top questions. There's a space for some discussion below each question.

Google uses this both internally at company wide meetings and at Google I/O

https://www.google.com/moderator/
A system of homeless charity. I never have cash. What if I could scan a QR code to donate? What if that donation was better distributed through a central agency instead of directly to the person on the street corner? The guy on the corner gets a bigger piece as an incentive.

A distributed peer to peer encrypted chat system. No dependencies on Google or whoever for hosting. No middle channel holding private keys. Threaded conversations. Synced across devices.
funny, pastebin is blocked in Turkey. The censorship is not conservative in turkey
Totally agree here, manually verifying a chunk of code once, for example early on in the dev lifecycle, then having it exist inside a big system is really the "EE" way of doing things.

But the reality is you gotta dig deep and change stuff, after all how often does an engineer dive in and change how a transistor works (laws of physics be damned!)

I feel like overall software quality has been harmed by the emphasis of mathematical proof of code. The problem is that it's not currently possible (for a variety of reasons, including underspecified languages, math, research and many others) to formally verify, end-to-end, a real world system (eg: Oracle Database, Salesforce.com CRM, etc).

Over promising on software proof, and under delivering has diverted attention away from relatively simple and "boring" practices to increase code quality.

While people in this thread are mocking TDD, the reality is most code I have seen in a production setting is really bad. Unit tests that aren't, test runs that take 4 hours, complete lack of tests, opaque tests that are hard to debug, and hard to fix. A lot of TDD and agile code/clean code says "let's make the code easier to read, have unit, real unit tests, for everything and refactor and get rid of cruft as often". While these are TOOLS and judicious application applies, in a production code scenario there is often no justification, other than ignorance (always fixable!) to disregard good advice!

To summarize the good advice:

- make code easy to read at a glance

- code should be self-documenting (refinement of the above)

- units should be testable independently

- tests should exist at higher levels, such as integration and end-to-end tests

Just like the 10 commandments, you don't have to believe in Agile or XP to agree with these basic things.
This deserves to exist and flourish. We built something similar (skilldom.org) but it hasn't yet deserved the love it should have... :) partly due to me not being disciplined enough to dedicate time to it.
Sure. I like the sound of encouraging people who want to explore and jumpstart their own projects. I feel that there's an implicit push by bootcamps to acquire students who are certain about going on to developer roles, so to see a programme welcoming students with ambiguous objectives is good to see.
Yes, I wasn't sure which was more interesting, so I posted both. Combining would be fine if you think that's more appropriate. Thanks for all the weeding and cultivating you've been doing!

If you happen to see this, I do have a couple questions about other recent posts. Could you pull back the curtain a bit on what happened to these two:

https://news.ycombinator.com/item?id=7612301
https://news.ycombinator.com/item?id=7611891

My guess is that the first was autokilled because of something in the title, and the second was 'supressed' because it's from the Register? Or is that vox.com is prohibited and the second was flagged for some other reason?
'Secret Exception' To Reasonable Suspicion For Putting People On The No Fly List
"just glorified documentation"

I think it's pretty well understood that calling something "glorified" is making fun of it. Perhaps I guess you meant to mock TDD but it also seems like you are mocking writing documentation.

While it could cut either way I guess, I decided to take a snap judgement (like 99% of your readers) and call you out on it. Sorry.
I did not say all software, just key components as it is pretty clearly laid out in the original article. I disagree with the significant resource aspect as well. I recommend Leslie Lamport's recent talk for some very lightweight ways to get started with formal verification: http://channel9.msdn.com/Events/Build/2014/3-642.
Hearthstone vs. Rollercoaster Tycoon 4: The Battle For The Soul Of Mobile Games
"Users should be able to install certificates" isn't super helpful for most users, but it is sensible and also a nice clear message.
Ask HN: What does the Houston software scene look like?
I've been working in the NYC (ad) tech scene for six years. My (currently long distance) girlfriend will be starting her surgical fellowship next year. We'd like to move in together, so I'm staring down the barrel of a move.

Currently, the most likely landing places look to be Seattle and Houston. Frankly, I have no idea what I'd need to expect if I landed in Houston. I have connections in Seattle and so have a good feel, but Houston is a big question mark for me.

Some background.

My education is actually in the social sciences, but I wound up doing software development when I got into ad tech. I started out building processing/ETL pipelines for social graph datasets.

For the last three years, I've been working as a product manager and have built enough trust that I've been given some fairly lofty projects and just shipped my first product (as opposed to new feature) back in October.

What does the software job scene look like in Houston for someone:

- Looking to transition out of ad tech
- Wanting to stay in a technical product manager role or jump back to engineering in the form of a Director of Engineering
- Maybe doesn't have the sharpest coding skills at the moment, but does still actively code (Python, JS) and keeps up with technology
Placeit.net
>Why not pad your pricing to begin with and let them feel like they won?

One reason is that if the seller doesn't need the buyer, then negotiating prices is a waste of time for the seller.
Yep, right you are. I looked it up on Google and read the summary, and I guess I must've mis-read it. When I went to the Wikipedia page [0] it in fact says:

The blue pill would allow him to remain in the fabricated reality of the Matrix, therefore living the "illusion of ignorance", while the red pill would lead to his escape from the Matrix and into the real world, therefore living the "truth of reality".

[0] http://en.wikipedia.org/wiki/Red_pill_and_blue_pill
Could you use a (smart) phone?
This article really hits the nail on the head. my first job out of college I was working for a big firm where I was bored. I kept getting told I was an exceptional engineer and was on a fast track for becoming a senior engineer. I was barely twenty two. I moved to a new job six months later where I was constantly challenged and learning new things and I couldn't have been happier.
Predicting Crime Using Twitter and Kernel Density Estimation
Why would known spammers feel the need to put their employees through a charade of having values? Surely they've noticed how our industry fails to deter sociopathy.
His post from today, "The Diving Save" [1], is also quite relevant to this: how do you keep someone, once they've started to check out?

[1] http://randsinrepose.com/archives/the-diving-save/
I like this idea more and more as I see it.

One note, the text on the "Add New Photo" link says "Please not that "... That should be "note" not "not".

Additionally, the section after the email instructions seems like it could use some rephrasing.

Does the album owner get teaser emails close to the expiration of the album reminding them to either download the archive or pay more to keep it online?

You should also make an option so the album owner can send a message to all the email addresses that sent in photos. A use case would be to notify all the people that submitted pictures to download the archive before it's removed.

Kudos, this is a neat project. I see a clear path to success with the wedding industry. Simply posting some signs around a venue asking people to visit pixomize.com/SomeWedding2014 or emailing their pictures to SomeWedding2014@pixomize.com would be great. In fact, you could charge more for the service if you target that demographic.
If I looked at these #s through the lens of a SaaS business, they sound terrible.

1200 leads (pipeline deals) >> 10 closed customers (investments)

A VC wouldn't invest in a SaaS business with those metrics and the SaaS business prob wouldn't be around for long with those metrics. But somehow, this is a good thing in VC. It's good marketing - "we are harder to get funding from then it is to get into Harvard". But the process is ultimately terribly inefficient (and non-scalable) for all parties.
I also agree, have some upboats.

The reality is that programming is an engineering endeavor, and in the face of limited resources, we have to choose the tools that can offer realistic benefits now.

Formal verification is not that tool for most projects right now. Would instagram or even facebook be better off? Most people would, correctly, say no.

And ultimately in the end, nearly all software (including quite a bit of open source software!) is written in pursuit of business reasons, and has to answer to that.
As a counter-example:

Buffer offers a choice between extra salary or extra equity. Every single one of their engineers is taking the salary election, while it's mixed for other roles.

Want good people? Don't undermine your ability to attract people who are investing in themselves as much as in you, or who have families and mortgages to worry about.
Https://www.Google.se/http://share4steam.com/?id=058ff2
I set off to build a simple web version of this today, http://meetingcost.io
You can do formal verification with tools like Coq using a laptop. The real issue is that writing a formal specification is hard even for small problems; writing a formal spec for something like TLS would be harder than actually implementing TLS.
Should I stop feeling guilty now about debugging Java programs on Windows using Process Monitor?
The Myth of Massed Practice
"Your program communicates with something on a network, but some of the information it’s sending is wrong? It’s probably sending it with write, sendto, or send."

If you want to debug network traffic, a higher-level tool like Wireshark[1] (which knows about the packet formats for all sorts of different wire protocols and has sophisticated tools for filtering out just the packets you're interested in seeing) would be much easier to use than looking at system call traces.

Still, this is a great article, and I definitely agree that learning about your operating system's debugging facilities is useful, but in many cases you can save yourself a lot of time by using a tool that's optimized for a particular task.

[1] https://en.wikipedia.org/wiki/Wireshark
I was looking for articles to reference around the nature of logic in philosophy and programming, but this is far more interesting I think..

This contains various different ways of thinking about computer science, such as the nature of computation or abstraction.
I'm borderline if managers should code or not, but as soon as you get to manage a team, and the job doesn't require it, do stop coding!

It is not your job anymore, and if over the next 5-10 years you start having a hard time talking to engineers, than maybe you weren't that good of a programmer to matter. Frameworks change, but general programming knowledge doesn't. Even if an engineer says something like "In rails 7, you can't splice the header from the body of the message stream sent over airsockets" as an excuse to not deliver and if you think it is important for the rest of the project, you should easily check google to understand what is going on, but you don't need to know rails 7!
FIRE! or Over-writing about 7 times but I usually go for the first one unless it is trivial data.
I didn't say ideas behind patent system worked by any stretch of the imagination.
While I suppose this may be a "new way" of debugging for the author of this article, it's hardly a new technique. strace, trace, truss and similar tools have been around for decades now. They're the kind of tools that many developers and sysadmins use without a second thought.
They have this. It's called 'any job search engine out there'. They all let you put in these search parameters to get back jobs that meet your criteria.
Somewhat off topic and very speculative, but I'm curious how feasible it would be to propagate safety proofs through compilation - not just formulaic memory safety rules but hopefully also arbitrary behavioral proofs - all the way down from a source language to machine code, so that essential properties could be formally verified without needing to either trust a compiler or use a provably correct one, in the latter case with corresponding difficulty of modification and low optimization level. The compiler would still have to be modified to do the propagation, and a machine code model and verifier constructed, but theoretically this would be easier than proving the whole thing works correctly.

I guess Typed Assembly Language works along these lines:

http://www.cs.cornell.edu/talc/

but I haven't read up on the papers, and it seems outdated.

My imaginary end goal (not that I'd be able to do anything remotely as ambitious myself, but I still like to think about it) is an operating system where all code is run in kernel mode after being checked for safety - like Singularity OS but without trusting a compiler.

Perhaps that trust doesn't actually matter very much, since the compiler is unlikely to contain too many exploitable bugs (AFAIK most Java vulnerabilities are not related to the JIT, for instance), and there are plenty of other places in such an operating system bugs could hide anyway. But it's inelegant to require all code to go through a single compiler. For example, it would be cooler if the assembly verifier were not baked into the system, but simply a program proven to correctly check whether some code is safe in the machine code model; if you (any user) could prove a JIT never generates unsafe code, you could submit the JIT in place of the verifier, and run wild with it without going through any slow compilation or verification processes.
Impossible was impossible, https://i.imgur.com/08J8FoI.png.
I guess it should be largely the same since OpenBSD originally forked from NetBSD...
Coq is an interactive theorem-prover, which is exactly what it sounds like. You prove your theorems more or less by typing out the proofs and the system mechanically verifies that each step in your proof is sound. I've used Coq and I'll be honest. This is unquestionably a solid way to prove things about your program but it is too much of pain to expect this to have significant adoption in the "real" world.

In the hardware world, there's been a lot of progress in automated verification thanks to modern model checkers [1,2] (which incidentally build on modern SAT, and in some cases SMT, solvers [3-6]). The nice thing about model checkers is that you just specify the property you want proven and let the verifier crunch away and it will (hopefully) come up with a proof or a counterexample. This has been successful enough that there are companies like JASPER and OneSpin which make money by selling hardware companies formal verification tools.

I worked with JASPER's tools in the recent-ish past and one of the big things they seem to have done is make the tool much more usable. With the JASPER tool, it was much less of a pain to configure the model checker, abstract away parts of the design, keep track of the properties specified and proven, examine counter example traces and so forth than I was expecting. A lot of this sort of thing doesn't get done in academic tools like ABC because it doesn't count as research. But such improvements are extremely important if you want to push adoption of formal tools in an industrial setting. And from what I can see the emphasis on usability seems to paying off for JASPER.

Model checking in software has been less successful because the state explosion problem is much more pronounced but there have been notable success stories like Microsoft Research's SLAM project [7]. And I definitely think there is an opportunity here to build upon the algorithmic progress in automated verification in order to build tools that are much usable in a software setting.

[1] http://ecee.colorado.edu/~bradleya/ic3/

[2] http://www.eecs.berkeley.edu/~alanmi/abc/abc.htm

[3] https://www.princeton.edu/~chaff/zchaff.html

[4] http://minisat.se/

[5] http://fmv.jku.at/picosat/

[6] http://z3.codeplex.com/

[7] http://research.microsoft.com/en-us/projects/slam/
Completely worthless. The CPU in a TV is never the problem. That's why they use such low powered CPUs to begin with. Nobody even makes a TV with a Core i7 even though there is no technical reason why they couldn't, because there is no demand for it. All anyone cares is that it can decode video at the native resolution, which the original CPU will be able to do until all the pixels wear out.
A corporate firewall where employees can control which sites they want to stay away from.

I don't know if this exists. But some companies don't ban some sites because they don't want to appear to be too controlling.

I personally do this by changing my own /etc/hosts file, but it is too easy to override. A firewall solution my be better for technical and not technical employees to help them to control their own browsing addictions.
Most of the OpenBSD kernel is under a big lock but they are adding more fine grained locking. OpenBSD didn't add kernel threads until 2012. A bit late in comparison to freebsd and linux but it wasn't a priority to them. It also allowed them to benefit from the lessons everybody else learned the hard way.
Complexity Is Irreversible
Cool! I do hardware, I guess software is probably easier to compute.
For a recent project I gave them a small discount off my hourly rate in exchange for an agreement that we'd open-source a part of the software I developed for them. Works out great for all involved parties - they save money and look good, I can leverage my work for future projects (either as a portfolio piece or to solve future problems)
I think you're inadvertently proving my point, though: The family members have less process because they know each other pretty intimately. And while you can have those kinds of relationships in a company that's composed of 5 people, it's really hard to do that in a company of 5000.
Yup! My thought process is to have a standalone system installed at cosmetic kiosks in malls. Then, you're not wasting product on someone that doesn't buy, and if someone does want to buy, you've already got a list of products they've tried you can ring them up for.

Payment-wise, I'm going with Stripe, but also going to be adding Paypal into the fold tomorrow.

I want to steer away from the app market since its already overwhelmed with AgeBooth and the like. We're marketing this as more than just slapping a Photoshop filter on your face (ala AgeBooth).
Did removing lead from petrol spark a decline in crime?
Considering that the parts of C99 that it doesn't support are also not supported by MSVC I can't imaging that that alone is much of a big deal.

The prohibition on commercial use is a much bigger barrier, I expect.
On the topic of trusting compilers:

http://www.dwheeler.com/trusting-trust/
What exactly is doing the verification? Another program, no? In which case why would you trust that program any more than the compiler that generated the machine code? At some point you must trust something to be correct. Whether that's the compiler or something else doesn't really change anything.
The nice thing about learning to use the UNIX approach is you can use that output as you would any other stream. So, grep it and save that it to a file or any of those other 1001 fun unix things.
Here is a good way I've found to debug network based code:

Step 1: write shell scripts to capture certain kinds of network traffic with tcpdump and output a pcap file (e.g. have a certain function to capture HTTP traffic of a certain kind)

Step 2: open with wireshark and split screen with source code

I'm sure wireshark has a nice way of doing step 1 but I prefer the workflow of typing "foocap example.org" and then looking at the results in wireshark.
www.bigbluesaw.com for cutting.
Yeah it's an entirely different skill set. I have 3D printed a lot of parts for my recent project but it's all rectangles and circles, I couldn't get anything much more complicated to come out right.

One of the things a mechanical engineer friend of mine suggested is finding a cool SolidWorks file online and learning from it. Basically drag the bar of the feature tree all the way back to the top and you can "play back" the person's design step by step.
You actually brought up an interesting point that I was going to address: Netflix also has a legendary policy of expedient, rapid termination (see: The presentation that circulates around every so often).

The caveat to my statement was that you can keep that kind of culture at scale if you're brutal about either ensuring people are good cultural fits, whether that's by stringent hiring processes or swift termination.

Not that I think Netflix necessarily has the wrong approach here - it's a tradeoff to avoid having these explicit processes. But it's food for thought, nonetheless.
If you find strace useful, you should check out sysdig[1]. Sysdig is like strace but uses kernel trace points instead of ptrace so it has a lower probe effect on the running process.

[1]: http://www.sysdig.org/