data.json for blackhulk project (10533 lines - 2106 posts)

data.json

[
  {
    "title": "Plan to throw one away[First]",
    "content":
      "This is a **software development story** from early in my career. The company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 When I had interviewed for the job, the interviewer had explained that I was needed to work on their JavaScript engine. The company was a web development tools startup, and they had spotted that it would be a good idea to have JavaScript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. There are now lots of products in this space but twenty years ago was probably too soon for this to be a success. Anyway, the interviewer told me that the JavaScript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so I might have to do a bit of optimization. Sure, I said, that sounded like it would be fun. Oh, and it had to be done for the beta release in two weeks’ time, so I would have to get my finger out. So, on my first day in the office ~~I needed to make a plan for what was left to be done~~. **Exactly which features** were missing? Was there a list? No, there was no list. Had any testing been done (with only two weeks to go, surely there should have been some)? No, there had been no testing. Could I talk to the programmer who had written the engine? No, he was the CTO of the company, and he was very very busy preparing for the release. So there was nothing to be done except check out the source code for the engine from CVS, compile it, and sit down with the first edition of David Flanagan’s excellent JavaScript: The Definitive Guide and work through the features. Sure enough, “one or two” things were missing. Global objects and functions like Math and parseInt weren’t implemented. There didn’t seem to be any string methods. Arrays were missing. Object prototypes didn’t work. At least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "Plan A",
    "content":
      "This is a **software development story** from early in my career. The company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 When I had interviewed for the job, the interviewer had explained that I was needed to work on their JavaScript engine. The company was a web development tools startup, and they had spotted that it would be a good idea to have JavaScript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. There are now lots of products in this space but twenty years ago was probably too soon for this to be a success. Anyway, the interviewer told me that the JavaScript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so I might have to do a bit of optimization. Sure, I said, that sounded like it would be fun. Oh, and it had to be done for the beta release in two weeks’ time, so I would have to get my finger out. So, on my first day in the office ~~I needed to make a plan for what was left to be done~~. **Exactly which features** were missing? Was there a list? No, there was no list. Had any testing been done (with only two weeks to go, surely there should have been some)? No, there had been no testing. Could I talk to the programmer who had written the engine? No, he was the CTO of the company, and he was very very busy preparing for the release. So there was nothing to be done except check out the source code for the engine from CVS, compile it, and sit down with the first edition of David Flanagan’s excellent JavaScript: The Definitive Guide and work through the features. Sure enough, “one or two” things were missing. Global objects and functions like Math and parseInt weren’t implemented. There didn’t seem to be any string methods. Arrays were missing. Object prototypes didn’t work. At least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascript engine. the company was a web development tools startup, and they had spotted that it would be a good idea to have javascript code running on the server as well as on the client, so that you could share your business logic and validation code between the client-side and server-side parts of your application. there are now lots of products in this space but twenty years ago was probably too soon for this to be a success. anyway, the interviewer told me that the javascript engine was nearly done, but there were one or two features that were missing, and it was running a bit slowly, so i might have to do a bit of optimization. sure, i said, that sounded like it would be fun. oh, and it had to be done for the beta release in two weeks’ time, so i would have to get my finger out. so, on my first day in the office ~~i needed to make a plan for what was left to be done~~. **exactly which features** were missing? was there a list? no, there was no list. had any testing been done (with only two weeks to go, surely there should have been some)? no, there had been no testing. could i talk to the programmer who had written the engine? no, he was the cto of the company, and he was very very busy preparing for the release. so there was nothing to be done except check out the source code for the engine from cvs, compile it, and sit down with the first edition of david flanagan’s excellent javascript: the definitive guide and work through the features. sure enough, “one or two” things were missing. global objects and functions like math and parseint weren’t implemented. there didn’t seem to be any string methods. arrays were missing. object prototypes didn’t work. at least the core syntax was working, but it did seem very slow"
  },
  {
    "title": "plan b",
    "content":
      "this is a **software development story** from early in my career. the company in question went bust eighteen years ago, so it’s probably safe to tell the tale now.1 when i had interviewed for the job, the interviewer had explained that i was needed to work on their javascrip