Scaling PHP with HipHop
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 90 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/40320 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 201321 / 90
2
5
8
10
12
13
14
15
17
19
21
24
25
28
29
31
32
34
36
39
40
43
44
46
50
51
52
54
55
57
58
62
65
66
67
78
79
87
88
00:00
Programmer (hardware)FacebookMultiplication signHost Identity ProtocolSpacetimeTranslation (relic)Lecture/Conference
00:35
Open sourceBitPoint (geometry)Product (business)Translation (relic)Host Identity ProtocolSoftware developerLecture/Conference
01:20
FacebookAsynchronous Transfer ModeServer (computing)CodeDatabaseCache (computing)FacebookComputing platformBitSequelWebsiteStack (abstract data type)DebuggerGoodness of fitXMLComputer animation
02:09
Discrete element methodBitRight angleAsynchronous Transfer ModeDatabaseWebsiteSemiconductor memorySubject indexingServer (computing)Web pageProxy serverOpen sourceSource codeTranslation (relic)WeightRun time (program lifecycle phase)Entire functionEvent horizonPhysical systemQuicksortIntegrated development environmentCodeCombinational logicPatch (Unix)Field (computer science)CASE <Informatik>Web 2.0Multiplication signComputer-generated imageryFeedbackElectronic mailing listVirtual machineHost Identity ProtocolFacebookIterationSingle-precision floating-point formatBytecodeLecture/ConferenceXMLUML
05:09
CompilerIntegrated development environmentAsynchronous Transfer ModeInterpreter (computing)DebuggerBytecodeCodeSoftware repositoryProcess (computing)QuicksortHost Identity ProtocolMultiplication signType theoryCodeBitOpen sourceWeb pageServer (computing)Virtual machineFigurate numberFunctional (mathematics)PreprocessorCodeAsynchronous Transfer ModeDatabaseSoftware developerRevision controlFacebookMessage passingBranch (computer science)Binary codeCache (computing)Scripting languageExtension (kinesiology)Interactive televisionSource codeBytecodeWeb 2.0AdditionFormal languageIntegrated development environmentJust-in-Time-CompilerPoint (geometry)Mathematical analysisRight angleSoftware repositoryGoodness of fitLibrary (computing)MeasurementElectric generatorUtility softwareProduct (business)Function (mathematics)Term (mathematics)Run time (program lifecycle phase)Regular graphCompilerInformation managementGodDemosceneDebuggerStructural loadInterpreter (computing)Thermal expansionLine (geometry)1 (number)Film editingSoftware testingMoment (mathematics)MathematicsRange (statistics)Computer animationXML
11:48
Server (computing)Configuration spaceDatabaseInstallation artServer (computing)Source codeBytecodeLine (geometry)Thread (computing)Scripting languageRepository (publishing)Product (business)Software developerBlock (periodic table)Sheaf (mathematics)Right angleConfiguration spaceBuildingCompilation albumSlide ruleBitComputer fileEquivalence relationLibrary (computing)Cache (computing)Social classMobile appRevision controlQuicksortPrincipal ideal domainOpen sourceMultiplication signBinary codeWikiFile formatSingle-precision floating-point formatHost Identity ProtocolFlow separationDirection (geometry)Term (mathematics)Asynchronous Transfer ModeSoftware repositoryDirectory serviceEvent horizonRadio-frequency identificationWeb pageDistribution (mathematics)Computer animationXML
15:15
Extension (kinesiology)Functional (mathematics)Greatest elementHost Identity ProtocolElectric generatorType theoryCodeQuicksortMultiplication signRegular graphEquivalence relationSoftware developerWeb pageRobotOperator (mathematics)Physical systemParameter (computer programming)CASE <Informatik>Goodness of fitDeclarative programmingGeneric programming1 (number)Different (Kate Ryan album)Server (computing)Equaliser (mathematics)Revision controlContent (media)Slide rulePrototypeSocial classSingle-precision floating-point formatPoint (geometry)Hacker (term)Memory management10 (number)FacebookProcess (computing)ImplementationJava appletElectronic mailing listInstance (computer science)MereologyBitSubsetFormal languageRepository (publishing)Installation artRight angleXML
20:18
Server (computing)User interfaceString (computer science)Web browserMenu (computing)Message passingExtension (kinesiology)Error messageSubstitute goodBoolean algebraMathematical analysisComputer fileMultiplication signLine (geometry)Type theorySoftware testingText editorSocial classContext awarenessIntegrated development environmentJava appletWeb 2.0Object (grammar)Flow separationHacker (term)MappingSet (mathematics)Functional (mathematics)Bounded variationNamespaceStandard deviationElement (mathematics)Division (mathematics)Generic programmingVector spaceNumberPhysical systemSoftware developerAsynchronous Transfer ModeINTEGRALInformationSoftware repositoryFormal languageComputer configurationRight angleAttribute grammarPrimitive (album)Function (mathematics)CASE <Informatik>Goodness of fit2 (number)Virtual machineNetwork topologyContent (media)Complete metric spaceOpen sourceCodeIntegerParameter (computer programming)Event horizonScripting languageHecke operatorCone penetration testXML
25:21
Multiplication signQuicksortOpen sourceRepository (publishing)Revision controlHost Identity ProtocolProcess (computing)XML
34:59
Lecture/Conference
36:59
Lecture/Conference
38:28
Lecture/Conference
39:22
Slide ruleExtension (kinesiology)Hash functionTemplate (C++)CodeAtomic nucleusCASE <Informatik>Computer fileProjective planeQuicksortSheaf (mathematics)Public domainVideoconferencingLibrary (computing)Host Identity ProtocolRegular graphOperator (mathematics)Open sourceOperator overloadingDomain nameRight angleLecture/Conference
41:59
Hash functionPoint (geometry)Set (mathematics)Goodness of fitLink (knot theory)Hidden Markov modelHost Identity ProtocolWeb pageFacebookMultiplication signQuicksortPower (physics)Slide ruleComputer animationLecture/Conference
43:03
Revision controlLine (geometry)Product (business)Software bugPoint (geometry)Server (computing)Stability theorySoftware developerComplete metric spaceCycle (graph theory)Multiplication signXMLLecture/Conference
Transcript: English(auto-generated)
00:00
Popular. Hi, my name is Sarah Golan. I'm a programmer at Facebook. I'm here to talk to you about hip-hop. We were here about three years ago, introducing hip-hop for the first time, and a few things have changed in that space. How many of you were here three years ago? A few? Okay. How many of you at least have an idea of what hip-hop is?
00:26
A lot of hands. You're probably all wrong. Hip-hop, as it came out three years ago, was a PHP to C++ translator that it would just kind of shove it off to make. That was a bit slow, especially for development work. It's completely changed. It's not
00:43
that product anymore. It only bears the name in common. Well, and some piping. Let's get into it. Let's talk about it a little bit. I'll tell you what's still wrong with it, because there are a few things still wrong with it. Hopefully it's to a point that maybe something you want to try it out, get involved, commit some things back.
01:03
Our open source picture was kind of broken for a while, but we're trying to improve that. Moving on, this is going to be what we're going to talk about today. Why hip-hop exists, roughly how it works, and why you should or shouldn't be using it.
01:22
The problem that we had at Facebook is that we've got, well, a few years ago, we had a few hundred million users. We had a few thousand servers. We had a lot of traffic moving, and we're all running this on a LAMP stack, like most sites. We've got Linux patching MySQL PHP, and this is running pretty well. PHP is a good platform.
01:44
It can run bad code pretty decently, and it can run good code pretty well. Unfortunately, as you start to scale out too far, you start to run into some problems. I'm sure anyone who's gone past a dozen servers has started to see some of these problems.
02:02
Your databases start disagreeing with each other a little bit. You have to build in some special caching layers. Your front-end servers start to get memory-locked, because if you're running PHP on Apache, you're going to be running in pre-fork mode. It doesn't really quite work in worker mode too well. PHP is not meant to be threaded.
02:24
So, what do you do about that? You make your servers run a little bit better. The easiest things to do are go for the low-encagging fruit. Make your databases work right, and that's going to get you a 2x improvement right off the bat. I've seen too many websites that are on their knees because somebody decided they needed to index every
02:43
single field in every single combination of field at infinitum, and they wonder why the rights take so long. That's why. So, obviously, go for the easy stuff. Don't try to redesign your entire system. Take baby steps. But once you've done that, what are you left with?
03:01
Well, in our case, we had done all those low-hanging fruits. We had done all of those places where we can improve our stack on the whole. And now PHP is taking up some 60% of our execution time. Can we speed up that 60% so that is a smaller portion? That's the idea for hip-hop.
03:25
Now, hip-hop, like I said, has gone through a few iterations in its time. Where we're at right now is we're actually taking source code, compiling that to a bytecode, similar to the way PHP actually does it.
03:43
We are running that bytecode in a virtual machine a few times to make sure things understand how things work together. And then at the very last minute, we do a translation to native code so that that can run at its full speed.
04:01
We've also removed Apache from this picture. We don't really need to remove Apache since we have now replaced PHP with something that's a fully-threaded environment. We can stick that on top of Worker, and it could work just fine. But for our purposes, we didn't need all the extra weight that Apache brings because Apache is a big Swiss Army knife that can do everything.
04:21
I love Apache, don't get me wrong. But it's more weight than we necessarily needed for Facebook. So we replaced that with an HTTP server based on libevent. It's very lean, it's very quick. Moving forward to today, we're actually thinking of reversing that a little bit.
04:40
We're going to expand the sappy layer out a bit, similar to what PHP has. So you can use Apache 2 with it, you can use ProxyGen, which is a sort of web server, sort of proxy server that we've developed in-house. We're about to open source that. You can keep using libevent if that's what you're happy with. Or FastCGI is the fourth one that's kind of on our list of things to get out quickly.
05:04
Ultimately, you could probably plug it into light or any other web server you want to do. So that's sort of the problem that hip-hop's trying to solve. And why we think it does a pretty good job of solving it.
05:21
I want to back up a bit and talk about some of the history. There are four incarnations of hip-hop. The first one, the one that we introduced three years ago at Fosdom, is called HPHPC. That is the hip-hop compiler. That's the one that takes that source code, says, well this is PHP, it looks a lot like C.
05:41
Let's just translate that instruction for instruction, pass that off to make, and that's great. It compiles, we get a big massive binary that runs over the web server, does all the work, and it's fantastic. This ran Facebook.com for about three years, up until actually last month we just retired it.
06:03
The trouble with this is that every time we do a production push, it takes about 40 minutes across 100 machines to actually compile all of our www code. This is horribly painful, it's something that's completely untenable in development mode. If you have one machine that's going to take, let me do the math, 40 times 100, 4000 minutes, that's a long time.
06:27
It's completely unrealistic for development mode. So we left our development machines running what we call APE, the Apache PHP environment. And that works fine, except they're not quite identical, right?
06:40
You've got a PHP on one side, you've got a hip-hop on the other side. Maybe the functions are implemented slightly differently, maybe there's some functions available on one that aren't on the other. We've done a few language expansions, we added generators about two years ago. We added something called XHP, which I'll show you a little bit more later.
07:01
This is a really fantastic output layer. But it means that our environments don't quite match. And although we can kind of throw some extensions into PHP to pick up the extra hip-hop features, and we can try to make hip-hop as close to PHP as possible, it doesn't quite work, it's a conflict.
07:24
So we threw together HPHPI, which is hip-hop in interpretive mode. This basically followed the PHP 2 style of script execution, which is, let's look at a line, figure out what it wants to do, do that instruction. Go to the next line, figure it out, do that instruction.
07:42
Absolutely no pre-compiling, no intelligent caching of the code, it was really slow. It probably ran at about a quarter the speed of regular PHP. But at least it was mostly consistent with hip-hop. I say mostly because we still missed a few things. This is painful, but it was kind of good enough for development machines.
08:04
We've also got the HPHP debugger. This is sort of a command line interface, it's kind of similar to PHP-A, the interactive mode for PHP. But it's got a few extra things, it's basically got GDB thrown in on top of that. You can attach to a running web page on your server, set breakpoints, watches, analyze what your code's doing.
08:25
When you bring up HPHPD, it'll actually load up all your source code, so you can start calling functions out in your main library of things. And you can interact with your actual code base very quickly and easily. Some people actually found this a lot more convenient than writing code and actually running it on their page.
08:47
About a year ago, we got our most recent version of hip-hop up to the point where it was ready to be used on our development machines, and that is HHVM. This functions a little bit more closely to the PHP 5 style of code execution.
09:04
We take source code, we compile that to byte codes, cache those in a database somewhere. When the page comes up to be viewed, we run those byte codes through a runtime interpreter. This is what PHP 5 does, this is what the Zen engine does.
09:20
And we're about on par in terms of performance with just the HHVM versus PHP. So what's the point of that, right? The point of that is we throw this JIT on top of it. After we've run our code a few times, we say, okay, we know where the code is likely to go, we know what all the types involved are likely to be.
09:43
We can start compiling that to x86 code. When we run HHVM with JIT, not only are we competitive with HPHPC, we're actually about 10% faster than it is. And that means about a 1.5 to 6x improvement over PHP. Now, that's a wide range, that's because it depends on how you're writing your code, and I'll talk a little bit more about that in a moment.
10:09
We also have an additional kind of version of HHVM called repo authoritative mode. In repo authoritative mode, we sort of do a preprocess of every script in your
10:22
source tree, compile it right up front, get everything in the database all at once. We can also do some additional analysis on it at that time, because we're not constrained by, oh my god, somebody's requesting a page right now, you don't want to go slow compiling your script. We can be a little lazy about it, we can look deeply into which one of these
10:44
code paths is likely, do we always see particular types going to this variable, that sort of thing. And this gives us another 10% gain over non-repo authoritative mode. So that's where we are at Facebook today.
11:02
Our servers actually, their utilization just dropped immediately when we did the cutover to HHVM last month. We're way faster than PHP, and I put a little asterisk there because we can't measure it exactly anymore, because there are a bunch of features in hip hop that are not in regular PHP, so it's hard to test everything.
11:23
Apples to apples, but what we can test shows that we're still a lot faster. And we're actually about to remove the HPHPC pieces from the source code out of hip hop entirely, because it's a bit messy and none of us really like it anymore.
11:42
If you are using it right now, you will still be able to access it on the HPHPC branch on GitHub, but I wouldn't use it, HHVM's much better. So how do we actually use this thing, how do we actually bring it up? Right now the only distro that's supported as sort of a first class distro is Ubuntu.
12:03
We actually are building a package for this right now that we're hosting external to the repository. I'd like to convince Ubuntu to pick it up, but there's a few things we need to do in terms of making our package dependencies a little bit cleaner before they'll actually pick us up.
12:20
Again, if you're installing for Ubuntu, you can just add one line to your ETC app sources list, app get update, app get install hip hop PHP. Done, you're ready to go. Otherwise, there is a readme file in the source tree, a few wiki explanations of how to get things compiled.
12:40
It's a bit messy, I'll be honest with you. libevent actually has to be patched before it's built, because we've got a few extra things for HTTPS in there. You need the most recent version of curl, 728.X, whatever. What else is in there? Libraries like TVB, Intel's Thread Building Blocks library, we need a really recent
13:04
version of that, and most distros only have version 2, we need version 4. So there's going to be a bit more work to do to actually get this thing installed in most distributions. That's the reason we're officially supporting Ubuntu, because Ubuntu's got the most recent packages for all of these things.
13:22
So let's say you've got it built and you've got it installed, let's actually bring up a server. This is a one-line configuration for you, this will get your server running right off the bat. This is a config file, this is a config format called HDF, there's a whole explanation of that format in the docs directory. But it's pretty straightforward, kind of JSON-ish, but not really.
13:48
This basic configuration is going to give you kind of a bad setup, though. It's going to put your PID file in a bad spot, it's going to put your bytecode cache in a bad spot, you don't want to do something this simple. This is more of a typical development configuration here.
14:05
Hopefully this should all be pretty straightforward, obvious stuff. Production is going to be not much different from development, you're just going to add a few extra configuration directives here. You're going to make sure that you're not logging all the warnings.
14:23
You're going to switch into repo-authoritative mode, where you're not going to interpret the file every single time. And there's a few things I want to point out in the lower left-hand corner of this slide here. That last line there is the actual startup of the server, equivalent to Apache CTL-Start.
14:42
The line up above it is for building the initial repo, that big database of all of your scripts from the source code. I've got that X'd out section there, because as of about two weeks ago, that was the line you would have run. We had a separate binary for HPHP mode.
15:03
We've actually just switched it so that everything is in a single HPHP binary and you pass the HPHP switch. So that changed a bit recently. Just FYI there. So, why hip-hop or not hip-hop? This is my pain point right here, this slide.
15:23
There's a lot of things that hip-hop does not support at this time. We don't support namespaces, although somebody's working on them right now. I'm hoping he will commit by March, April sometime. We don't have a good extension story, really.
15:41
If you want to write your own hip-hop extension, you kind of have to go through some hoops. Somebody's working on that as well. I'm hoping he's also going to commit in the next month or two. And there's a whole bunch of extensions. I've got the big ones listed, well, the standard ones listed out on the bottom here. We're not currently supporting them. As soon as we get our extension story fixed up, we're going to create the equivalent of Pickle,
16:05
a repository for all the extensions that aren't necessarily part of a normal install. And we're going to put those in there and you'll be able to install them, hopefully with a single command. Knock on wood.
16:20
And also, it may just not be worth it for you. Again, Facebook's got a few tens of thousands of servers. It's worth it for us to get that, in our case, 6x performance increase because that's one-sixth as many servers that we actually need. And that translates into a lot of operational expenditures,
16:41
hundreds of millions of dollars, something like that. That's not peanuts. Maybe you're running your server off of one machine and you're getting a thousand hits a day. Hip-hop's not for you. It's not worth it. You're going to have to train your ops people how to deal with the new deployment style.
17:02
That's not a big outlay, but it's something. Things to consider. Now, why hip-hop? Well, performance, like I said, this is sort of the big thing that I'm just going to keep harping on over and over again. If you're running your code three times as efficiently,
17:21
then you need one-third as many servers. The further you go, the more that makes a difference. Even with something like AWS, if you have to have fewer EC2 instances, that's going to be less money. Something to consider. Now, I focus on extension development on the regular PHP side.
17:42
I wrote a book on it even. So when I look at the extension development story between the two, even though it's a bit harder to get started on the hip-hop side because our tooling system's not there yet, I do think writing extensions for hip-hop is much, much, much easier, and I've got examples of both up here. The top one is a simple hello world type function in regular PHP.
18:05
You've got to go through this process where you pull things off the stack and you have to do some explicit memory allocation things. I've got the equivalent function in hip-hop down at the bottom. In hip-hop, your function prototype is actually what it looks like in PHP land.
18:22
My function here takes four parameters. I've got those four parameters on my declaration. It's, at least to me, a lot more intuitive. There is the difference, of course, that we're in C++ land on hip-hop versus C on PHP. C++ can be a little bit scary because of all the magic that it does,
18:43
but it does have the nice advantage of cleaning up after itself really well. So, take the good with the bad there. We've also got a lot of language features that you're not going to find in regular PHP. I should put an X through the first one, generators, because PHP has actually now adopted generators.
19:03
A nice guy, Nicky Popov, I believe his name was, I hope I'm not getting that wrong, decided PHP needed generators, wrote up the whole implementation, submitted it to the list, and a few weeks later, we've got an implementation that is a superset, really, of hip-hop's version.
19:23
The PHP version has a few extra features that we're now going to take from PHP so that everybody's equal. Generics is a big thing. I don't know how many of you are using PHP and wish you had generics. They're definitely something that a lot of C++ developers like,
19:40
Java developers like them. Maybe you're not sure what they are. We've also got some sort of hacks in there for strict typing and specialized collections. They're sort of like arrays, but special. I'll show you a few examples of those. I mentioned XHP earlier. This is our HTML-like syntax that's embedded within PHP.
20:06
You'll notice I've got these tags here. There's no quotes. It's just, here's a tag, here's content in it. That's because these XML tags are now their own first-class entity within hip-hop. Now, why does that matter?
20:20
Is this just concatenating things together and it doesn't matter? No, these are actually classes and objects that know how to deal with the content they're being given. Most importantly, they know what the context of that content is. You can see that in the output here. In the case of $good, we've declared that using XHP tags,
20:41
you've got a paragraph, welcome, some user data, and paragraph. If this were not XHP, if this were just something inside of a string literal, this would be a dangerous thing because the user can provide any kind of data they want to throw in there. Because it's XHP, it knows that this variable substitution we're putting inside that paragraph is supposed to just be content.
21:04
It's not supposed to be HTML tags. It's not supposed to be anything that the browser is actually going to interpret. So when it outputs it, it's going to do an HTML special cars on it. And we can see an example of that in $evil, where we put it inside of a string literal,
21:20
and what we get is ampersand, LT, semicolon, script, blah, blah, blah. So that XSS never gets a chance to go in. This is not something that a UI designer should have to think about. A UI designer should just be putting in layout. And this allows a UI designer to focus on that. Now, if you really do want to enable XSS,
21:41
you can do that with this HTML function. I don't recommend it, but whatever works for you. So XHP is extensible. We can create our own elements, not just standard HTML stuff. In this case, I've suggested a possible UI menu element
22:02
and UI menu item element to go in it. This may then get translated out to divs and spans and list elements, whatever. The panel you see on the left here shows extending XHP elements. You'll see they have these special namespace separators of colons.
22:21
These get translated by the uses on the right-hand side. Any time we use a tag within PHP scope, that turns into colon tag name as a class. It instantiates that class, passes in whatever attributes it has as attributes, and anything within the tag as its children.
22:43
So my UI menu takes an attribute of a title. That comes in as title equals option one. Sorry, no, title equals hphp's corner. And it takes children of any number of UI menu items. Hopefully that's pretty straightforward just looking at that.
23:04
Hack is another extension. I hate the name of this because it's so nondescriptive, but what hack is is an extension to the language to include strict typing. Everywhere. We can tell all the function parameters, what they're taking in, including primitives. We describe what the return type of a function is,
23:23
and what this gets used by is twofold. First, we have an integration with our own editor that we've written. We're going to open source that as well, by the way. That editor is going to look at those informations, and it's going to make sure that you're using these functions correctly. So you catch these errors long before you ever actually run the code.
23:42
It's doing all the static analysis constantly in the background. The second is during runtime, it's going to enforce these type checks all over the place, and it's going to throw the right kind of errors when things happen, and you're going to see them much quicker. You're going to see them actually when you're compiling to your repo authoritative mode. It's going to trace all the possible information everywhere it goes in the system.
24:04
It says, warning, this might come out wrong in certain situations, or error, this is always going to come out wrong. The other thing we show on here are our collections. In this case, I've shown a vector event. This is basically like having an array,
24:20
but you enforce that it's always going to be numerically indexed, because it's a vector, and it's always going to contain integers, because that's how you've typed it, and this is using our generic syntax here. We've got maps and sets and a bunch of variations of those in there as well.
24:40
I mentioned the specialized IDE we have. This is a web-based IDE that you run a little Java server on your development machine, and that exports a web server, gives you an editor. It can be shared between multiple people on the same file. It integrates with Git so that you can see annotations and history on any given line.
25:04
It integrates with Hack so that it knows what types are expected. It does auto-completion for all of your stuff going in. We're still kind of testing that right now, and the tools that we have that are testing it are just loving the hell out of it. We're definitely going to open source that soon.
25:24
That's the end of the lecture portion of this. I'm hoping you have a bunch of questions, so I've left plenty of time for that. Oh, please have questions. Well, I'll talk about some of these resources then. Obviously, the repository itself is on GitHub.
25:43
Now, I will say that the way we're dealing with pull requests is kind of bad. We basically had nobody working on the open source version of hip-hop up until about last summer, when I took it over and I've been trying to clean things up. But we still have a process where all of our commits have to happen internally first,
26:03
and then we push them out to GitHub. I know that's broken. I know that's not good OSS. We're going to make that better. I promise. So when you look there right now, you're going to see a few pending pull requests. Those are not pulled in either because they were submitted two years ago
26:21
and got ignored because nobody was working on open source, or they've been partially integrated and there's still a few pieces of them that need to be pulled in.
39:35
Our goal—oh, we even have audio. Look at that. We might even have video. I'll stand back up here. Our goal for the next year is to try and hit 150% of what HPHPC was capable of.
39:49
We'll see if we meet that. Because high ping likes C++.
40:03
The HPHPC project was started just as a hack by one guy, and he likes C++, and so that sort of became the nucleus of it, and that's when it stayed. I've actually started to like C++ because of hip hop. I used to hate it. I'm like, templates. There's magic.
40:23
Oh, operator overloading. There's magic. I have no idea what's going on in this code because it's all magic. Hip hop's kind of converting me. We'll see.
40:42
So you might have noticed on one of those—oh, we even have our slides up. You might have noticed on one of these earlier slides, I had some blackout sections. There are some things that I'm not allowed to talk about yet. I can say they're cool, but that means nothing. There are some features. Yes is all I can say.
41:05
Oh, and there were also, on one of those earlier slides, I should mention, some of these have asterisks by them. OCI in particular, we actually have an OCI extension internally, but it requires some weird stuff with non-public domain DLLs.
41:25
Or SOs, rather. So we can't actually release it directly. I'm working on finding a way that we can make it an optional build in case you happen to have that SO file. I hate closed source stuff.
41:41
So mhash is starred just because the hash extension supports everything that mhash does. So honestly, if you're using mhash right now, you should probably switch over to the hash extension, which both regular PHP and hip hop support fully. There's kind of no reason to stick with it. It requires an external library that's GPLed, and I have my own issues with GPL.
42:04
No, sorry, it's not GPL, it's LGPL. Otherwise we wouldn't be able to link it. mhash is effectively supported through hash, is the point. Nothing? Where are we at?
42:24
Oh, we're fine for time. Nobody was scared of the dark. Actually, you all seem to come out in the dark. Is it because the camera's back on? Let's kill the power! It is too early a morning, I agree on that.
42:41
Alright, then what else can we talk about? Let me put that resources slide back up. I encourage you to like the page on Facebook if you want to get announcements about what's going on. I plan to post a fairly large roadmap of hip hop for the next year.
43:02
It'll tell you exactly what we're planning to do, when we expect certain features to come online. We are going to start versioning. We're going to do some branching. We're going to say, okay, this is version 2.0.x and it is stable within the 2.0 line. We're not going to do new features, we're only going to do bug fixes so you can have a guarantee of stability for your production servers.
43:25
What else have we got? I don't know, that's it really. Well, the FBIDE, yeah. When is that going to be released?
43:42
We are still in development cycle on it, so we're not quite to a done point yet. We don't even have everyone internally using it. If I were to take a completely scientific wild day guess, I would probably say that we are going to get to feature completeness.
44:05
Call it summer. That's a completely off the cuff guess. No guarantees. Alright, we're within five minutes of the ending time, so why don't we go find some beers. Thank you.