Yeah, I had the same experience in my area. It's so strange to see so many people (online, and locally) strongly assert that Costco has the cheapest price on many goods. It's a strangely pervasive notion. We thought that we must be missing something!
Sure, some specific items are always cheap -- like the rotisserie chicken. But outside of those few things, you really have to look for actual savings, and that's true even of baby products which so many in our area seem to get at Costco. In many cases, we would be buying something in bulk for more money than at Winco or Kroger.
Shopping there is also rather disorienting... many times an item we bought one week would be gone the next. Or items would unpredictably shift locations.
As some commenters have identified, there may be specific items you want that are in fact cheaper at Costco. And I only have personal experience from my area, which is not a big city and has cheaper local grocery prices than a more urban area. My main point is: if you've been shopping at Costco assuming you are getting a good deal, you might want to double check against other stores!
What do you mean? Nearly every native English speaker who works with Coq pronounces it "cock" (from experience at POPL, PLDI, and other PL conferences).
Personally, I'm very happy that they are changing the name.
I wrote a tool that may be useful here; it generates a TypeScript definition file and runtime type checking logic given examples of the objects you want to accept.
You can capture a heap snapshot in most browsers now using development tools. However, even a blank webpage (about:blank) has tens of thousands of objects allocated for the default JavaScript/DOM APIs. It's challenging to manually grok a JavaScript heap.
I recently wrote an automatic memory leak detector and debugger, which makes this a lot easier (imo) [0]. You write a short input script that drives the UI in some loop, it looks for growing things (objects, arrays, event listener lists, DOM node lists...), and then collects stack traces to find the code that grew them. While it won't find all of the leaks, I was able to eliminate an average of 94% of the live heap growth I observed in 5 web applications (which found new memory leaks in Google Analytics, AngularJS, Google Maps, etc).
More information about the technique can be found in a PLDI paper (which I presented last week :D ), which I tried to write clearly so that it is accessible to a technical audience (i.e., non-academics) [1].
You're right; when it is running in the browser, isomorphic-git does not have access to the operating system's file system. Instead, it uses BrowserFS [1], which emulates a file system abstraction on top of arbitrary storage backends. It supports IndexedDB, localStorage, and Dropbox, among others. (Disclaimer: I am the author of BrowserFS.)
Well, this is useful! I recently built BLeak [0], an automatic memory leak debugger for the client-side of web apps, which consumes heap snapshots during the automatic leak debugging process.
I had to work around the DOM limitations of V8 heap snapshots by building a JavaScript 'mirror' of DOM state that I could examine in the snapshots [1]. Perhaps I'll be able to strip out that logic and rely on the improved snapshots!
I pay a low monthly fee for four recipes a week and have access to the archives if I don't like some of the recipes. I like to jokingly call it 'Netflix for meal recipes'. Each recipe has a vegetarian, paleo, and gluten free variant, and it creates a shopping list for your week. You can get a free trial if you want to see what it's like.
Recipes specify what you can prepare ahead of time (so you could do most of your prep for the week in one go), and contain embedded videos showing how to do some of the prep steps if you are inexperienced.
I will note that I simplify some of the meals. For example, some recipes contain salads and specify how to make a particular salad dressing from scratch, but I opt to use prepackaged salad dressing to save time. Other recipes specify expensive items, like capers, that I skip.
I also have lost weight eating these recipes in the portions specified, which has been quite nice.
(Note: I'm not affiliated in any way with CookSmarts; I'm just a super happy customer!)
Our lab addressed some of the issues with Stabilizer [0], which "eliminates measurement bias by comprehensively and repeatedly randomizing the placement of functions, stack frames, and heap objects in memory".
During undergrad, I wrote up all applicable college assignments using LaTeX for ~3 years. I recommend it if you want the ability to skillfully typeset math or if you plan to attend graduate school.
Pros:
- Transcribing from paper often revealed problems with my solutions
- Easy to modify / improve solutions once typeset
- Easier for me and the graders to read (I have bad handwriting)
Cons:
- Steep learning curve (first assignment took me many hours to complete, but provided the template for future assignments)
- Painful to edit sequences of equations if you are explicitly showing your work
I wrote a library and command line tool that generates TypeScript types for JSON objects from samples. It can also generate "proxy" objects that typecheck JSON objects at runtime, so you can code against JSON services without fear!
The use cases include:
* (Types) Generating quick-and-dirty TypeScript types for a web service or other JSON service you are coding against using response samples in its documentation.
* (Proxies) Ensuring that your code fails reliably when a service returns a JSON object with data that you do not expect. (Otherwise, your code may chug on with an undefined value and fail in a weird place!)
The generated proxies are also useful for non-TypeScript code when compiled to plain ole JavaScript.
To generate types from samples, I adapted the technique used in the F# Data library, which is described in the following paper:
To better explain from my previous comment, the use case is that you can take a Java program and run it in the browser with no modifications. So, if you have a legacy program or library and rewriting it would be a large undertaking, you can run it in DoppioJVM.
Performance is 24-40x over the HotSpot (Oracle Java) interpreter on compute-intensive benchmarks. The primary use case is for non-compute intensive code.
Thanks, rektide! Streams support haven't been added since a) there hasn't appeared to be great demand from folks using the library, and b) I haven't needed it for any project at all.
Feel free to leave comments on the issue if you or others would like to use BrowserFS but have been dissuaded because it lacks streams. I'm interested in your use cases. If your files are relatively small, then basic stream support can be bolted on with 100% preloaded files. If they are larger, then it would require a larger effort to bolt on incremental file loading into each backend to support streams.
Here's the only thing I could easily find via Google [0]:
"The basic design right now is that we draw every pixel of every frame, but there's a lot of overdraw when things overlap. This shows up in the moiré demo where there's a lot of overlap. Also we don't have enough information to do subpixel antialiasing. gw had a great idea to solve both of these problems. The prototype he built uses a ray tracer to trace through all of the objects and draw each pixel only once. That should lead to new features like subpixel AA and also more consistent performance."
It would require a complete rewrite; I commented previously [0] describing how WebAssembly seems inappropriate for Doppio, and also discussed similar thoughts about SharedArrayBuffer [1]. Also, the main source of slowness is due to the fact that Doppio uses a JVM interpreter and does not JIT; it could be much faster than it currently is with additional engineering.
Yes; the paper mentions CodeMoo.com, which the University of Illinois created independently of us to teach basic programming skills to kids [0]. The file system component is readily used by the Internet Archive for their MS-DOS collection [1]. A number of other instructors approached me regarding using Doppio for in-browser IDEs, but Doppio is somewhat cumbersome to integrate into webpages, and never had the time to dramatically improve its documentation and ease-of-use. I believe that is a more fundamental barrier to using Doppio than its performance, especially since you can run Doppio in a WebWorker to avoid some of the responsiveness issues.
Also, note that Doppio is an interpreter, so there is significant interpreter overhead. Using a JIT compilation approach would improve performance, and a contributor is currently working on a basic implementation. I honestly believe that it could become significantly faster with additional work, but as a single person with other projects, I lack the resources to do this work myself.
It's better if you are writing new code for the web and want to use a different language, but Doppio is better if you need compatibility with existing JVM code. The goals are different.
Sure, some specific items are always cheap -- like the rotisserie chicken. But outside of those few things, you really have to look for actual savings, and that's true even of baby products which so many in our area seem to get at Costco. In many cases, we would be buying something in bulk for more money than at Winco or Kroger.
Shopping there is also rather disorienting... many times an item we bought one week would be gone the next. Or items would unpredictably shift locations.
As some commenters have identified, there may be specific items you want that are in fact cheaper at Costco. And I only have personal experience from my area, which is not a big city and has cheaper local grocery prices than a more urban area. My main point is: if you've been shopping at Costco assuming you are getting a good deal, you might want to double check against other stores!