Try 6NF[0], not only do you get separate logging for when the row was/will be marked deleted, but you have a record of when the DB believed that the record was/will be deleted. Also true history and rewind capability.
Right, thank you for reminding me about the term. I like to see databases that generally follow this strategy, while providing higher-speed access to current data through materialized views [1].
> Too often I try to access Java or PHP web services from .Net, where the tooling is very strict, and it just falls apart. Or I'll have to use something via JS that is just excessively painful to use in practice for no good reason.
On the other hand trying to use anything from .NET land that implements WS-Security from PHP or Java is also exceedingly painful. I recently had to integrate very similar APIs from 5 different companies into an internal application...
One used an HTTP(s) REST API written in PHP, it used mod_auth and I was done in 30 minutes.
One used SOAP with some custom extensions, I hacked around a bit with the PHP SOAP classes and was done in a few hours.
One used WS-Security, and after a few days of hacking around I ended up using Netbeans' tooling to generate a Java client that could consume the service and forward the results to PHP.
Another used a (more recent) version of WS-Security and the same trick wouldn't work, so I contacted their support who admirably tried to create a java client to consume the service, gave up, and created a regular SOAP bridge for us to use.
One company is still trying to get our AD credentials set up with their vendor software that uses Biztalk somehow (they've been scarce on the details) after two months of waiting.
RESTful services in PHP and Java may not have a pretty GUI configuration tool, but they are much simpler to get working than SOAP and any of the MS extensions in my experience.
It's worth noting that you can mount very simple SOAP services in .Net (doesn't mean that people do)... WCF for example gives a lot of ways to mount your services together, or separately.
That said, I've never really been a fan of SOAP in general, and WS-(death)* is painful in any system. Funny enough, I've found node.js to be the easiest middle-man to coerce into using different services as a gateway, and it's my go-to when a wsdl doesn't import cleanly into a .Net project, and just define my own JSON/REST interface in front of the foreign services for the parts I need.
AD integration is particularly painful, and pretty much only works in IIS, in that case, I'd lean towards writing a shim in ASP.Net MVC exposing JSON endpoints, in a similar fashion.
I don't believe hstore supports nested structures, which would make it less than a drop in replacement for many NoSQL use cases. Native JSON support should fix that though, so good news everyone!
Postgres supports native nested structures. Well, as long as your structures are not circular.
JSON everywhere is really a bad choice for most data structures. It's like having no structure at all.
Well, I'm arguing that flexible schema is better than no schema. And in practice schemaless is only about schema defined outside of database. It's a solution to the wrong problem.
hstore is just based on a text format, so if it doesn't support it normally, you could just cast the results of each query to a new hstore, something like `select (data -> foo)::hstore -> bar`.
It's probably not a good idea though ;) You don't get any benefit of indices in that case, and I'm not sure what would happen with nulls.
I spend most of my time in dynamic languages so I have to ask... is this that much faster than a good regex library that it warrants a hand rolled state machine? How normal is something like this in a typical C/C++ codebase?
A "good" regex library will dynamically generate code; and if the regex is simple enough, generate code that implements a DFA rather than NFA (or PDA, for Perl regexes). So for a "good" library, no, it won't be much faster.
But very few regex libraries are that "good", because it's a combination of extreme speed with very low flexibility (DFA has exponential state explosion in worst cases compared to equivalent NFA, and isn't able to deal with e.g. backreferences). The vast majority of good regex libraries will be an order of magnitude slower. Average regex libraries included in most language distributions will be slower again.
The chief exception is compiler lexer generators like lex and flex. They produce code very similar to the state machine linked. And that's probably the most common place to see this kind of thing.
Encoding the state of the machine implicitly as the program counter, rather than an explicit state variable, often results in more readable code and is the more usual way to do it when writing it by hand. It also saves a register, important on some architectures. But the technique has slightly more limited expressiveness owing to needing to stick with structured programming constructs.
People (should) only implement things in C/C++ after thoroughly profiling the dynamic language POC and being sure they need the performance that a C implementation affords. So yes, the C implementation is going to sacrifice readability for performance. Of course, there are better and worse ways of accomplishing the same thing.
I don't want to sound nitpicky buuuuuut in text based emails folks have been using bold, /italics/, _underlining_, and {{{ preformatted }}} text for a long time with slightly different syntax. How attached are you to the one you chose? Would you be open to accepting a patch to use the older syntax?
I once tried to write a markup parser with slashes for italics, then I understood why no parser seems to use them. It interferes with URLs, dates, slashes as "or", etc.
I feel like this article on generalization could be a biography of my life based solely on the introductory paragraph, but I don't have enough time to finish reading it to be certain.
Well, I mean actually that it is not in the sense that it never will be. It may not sound nice but just basic logic is not for everyone. Now if you mean some future utopia or something ... that's not really interesting to me. In such a case then you could never fault someone for saying "everyone should be maximally good at everything" but it has no verisimilitude with reality.
I don't think they are actually driving any business away from github or I'd be more angry. This seems to fit a niche for people that would like to use github but legally can't put their code online (even in a private repository). It's github for intranets.
Agree though, github deserves all the karma we can throw at it.
However, it starts at $5000 per year and the main group amongst people I've heard using GitLab has been companies not willing to pay that $5000 (but who otherwise would probably go with GitHub - that is, they're 'satisficing' rather than choosing GitLab as such).
We've tried switching from GH Enterprise to Stash (because of the $5000 thing, which pisses me off and makes me feel like I'm being ripped off at the same time!), but it's really "not there yet".
The file browser sucks, the repo management doesn't make sense (repos live in projects, instead of organization/project or person/project), you can't run git via ssh on port 22, no activity stream (so you need to combine it with Fisheye), etc.
The price of Stash is really the price of Stash + Fisheye. At that point you're only looking at $2500, but still. Unfortunately for us, GitHub issue tracking and wiki suck compared to Jira/Confluence. So we run GH Enterprise + JIRA + Confluence. :)
I know of some fairly sizeable clients who are looking at gitlab because they need a github they can modify - github enterprise doesn't include source code does it?
I thought the point of autoloading was to make things easier, not to replace require_once with something more verbose. Why should I have to import classes from within my own package?
It's a symptom of people trying to solve everything with one toolset ("Me know hammer, me use hammer!").
In practice, most OO projects regardless of language have classes like 'LatestThingOtherThingIKindaRememberSomethingSomeoneElseWroteDontTouchIt', combined with a non-negotiable and often intrinsically (looking directly at any given piece of code) inexplicit set of dependency assumptions around the global object model.
In general we need less OO, and more immediately apparent, procedural, loosely coupled code. Programs that "do one thing and do it well".
[0] https://en.wikipedia.org/wiki/Sixth_normal_form