I stumbled across hyperdex.org, a nosql database contender, after reading on hackingdistributed.com/tag/hyperdex/
Having read their documentation and browsed their git repository, it looks like a relatively promising piece of technology (I most like the easy cluster deploy and backup).
However, all trails (except a handful of edits in the macaroon lib) seem to go dead as of Oct2015. Has the project been abandoned?
I'm the main developer of HyperDex. Per https://github.com/rescrv/HyperDex/issues/232 I posted:
"I've shifted my focus to developing Consus and am no longer a part of the company or research group behind HyperDex."
Related
With the move from SproutCore 2.0 to EmberJS there was the namespace and Github repo migration. Core things seem to have moved to the http://github.com/emberjs organization Github account while there are some others that seem to have been moved to the "addons" account http://github.com/emberjs-addons.
I am currently investigating EmberJS for use with a RESTful server, serving up JSON.
My question is: Do I use the new http://github.com/emberjs/data code or the older http://github.com/emberjs-addons/sproutcore-datastore code? I would assume the former but I would just like to be sure as well as get some clarification on what is going on with the old SproutCore "addons".
The emberjs-addons are ports from the old sproutcore ecosystem. They are not modified and it looks like they are not receiving much attention from the emberjs core-team. They are concentrating on the new "emberjs-data". However, the old datastore is production proven and the modified version does work fine with the current emberjs relase (0.9.3).
In contrast, while the rewritten version looks really nice, it is explicitly stated in the projects readme that it is not considered "production ready", yet.
Which one should you choose? In my opinion that depends on your project. If you are looking for something stable or you want to put your app in production any time soon, I would give the "old" sproutcore datastore a go. On the other hand, if you are just starting with your project use the new and shiny "emberjs-data" but be warned that you might have to fight around some edges.
I have been using ember-models with my own REST adapter while I am waiting for the ember-models one to be completed. git://github.com/ebryn/ember-model.git
I've been checking out Faxien+Sinan and Rebar, and the basic philosophy of Erlang OTP seems to be, install applications and releases on a single Erlang image instance. What are the best practices for keeping releases self contained? Is there a way to package releases such that you don't have to modify the site for machines that you're deploying to? How about gathering all dependencies into the codebase for management?
Perhaps I'm going against the grain... I come from a Java background and the philosophy of "nothing pre-installed but the JVM" seems very different.
IMHO this can't be answered in a few sentences. You should have to read some parts of the included documentation, especially "Erlang/OTP System Documentation" (otp-system-documentation-X.Y.Z.pdf, with X.Y.Z being the version number), or have a look at the book "Erlang and OTP in Action" because throughout this book there is "one" example of a "service" with different "parts" from the first steps, using Erlang/OTP concepts and finally building a "release".
IMHO this is currently the best book around, because it not only introduces Erlang, but also shows what OTP is and how OTP is used for a project. And it is not just a collection of loose samples, but everything is build around a single project.
I'll describe the approach that currently works for me for regular (often daily) releases to a small number of instances on EC2:
I set up my project with rebar and check it into github.
All of my dependencies are listed in my rebar.config file (they too are on github).
My Makefile looks similar to what I described here.
My EC2 image only has a regular build of erlang and no other libs installed by default.
To create a new node, I spin up an instance, clone my git repository, and run make. This will fetch my dependencies and build everything.
To update my code I do a git pull and a rebar update-deps. Depending on what changed I may restart the node or, quite often, I'll attach to the running node and reload the updated modules. It helps to have start and attach scripts as part of your project.
It may be helpful to look at how a project like webmachine is packaged.
I don't know much about the standard OTP release management system, other than it looks like a lot of work. Because this seems counter to rapid deployment, I never gave it a serious try - though I'm certain it makes sense for other projects.
I want to do something a bit like they have on IMDb - every film and every person has a forum dedicated just to them. I also want to have a forum on the main message boards, which would show all the threads from the film pages and another forum for all the threads from the people pages.
I've been looking at DjangoBB, Dinette and Sphene (SCT). DjangoBB looks like it has the most features and it's very elegant. Dinette doesn't seem that far behind. Sphene has a few disadvantages - less features I think and it makes me dependent on Sphene's Community app, but it seems like it might be the easiest to use in my scenario - I've seen examples of Sphene being used in similar fashion.
I'm pretty sure all three can be made to do more or less what I want, but would love some opinions on what might work best for me.
Another thing to consider: you could just use django-threadedcomments. It won't be as full-featured as installing a full forum solution, but has the advantage of being very compact and flexible -- basically, threaded comments can be attached to anything (a Person, a Film, etc).
It appears that DjangoBB and Dinette are not set up so that forums could attach themselves to a record in this fashion. Not sure about Sphene but it sounds like you'd have to use the entire community app.
I've set up a very, very simple Discussion app that could perform what you want. If you're interested let me know and I'll put it up on github for you to take a look at. Note that it's not at all full-featured like the ones you mentioned.
A bit late to answer this, but I think it might be worth mentioning The Pinax Project, which is django-based and is geared toward rapid development of social websites with many applications integrated together and customizeable at the user-level.
Do you use a wiki in your company? Who uses it and what for. Do you share information between projects / teams / departments or not?
We use ours to store
Coding Style docs
Setup and Deployment procedures for web servers and sites
Network diagrams (what are all the servers in Dev, Staging, QA and Production called etc.)
Project docs (pdfs, visios, excel, docs, etc.) are stored in SVN. For the non-techies we have links to those docs in the wiki that point to an up-to-date share on my box. (tip: some wikis provide source control integration but ours doesn't)
Installation and Setup procedures for development tools
Howto's on things like using our bug tracking system, our unit testing philosophy
When doing research on a topic I often capture the important information in a wiki page for others to learn from
I've seen them used to keep seating charts in medium to large size organizations for the new people
At my previous company all of the emergency contacts and procedures for handling a critical outage where available on the front page of the wiki
The best part about a wiki is that it's searchable. Some wiki's support searching inside uploaded or linked docs as well.
If you setup a wiki and encourage or even require people to use it the amount of information that will accumulate can be amazing. It's definately worth the effort especially if you have someone in IT with some spare time on their hands to set it up.
Do you use a wiki in your company?
= We use it for the purpose of a Knowlede Based. Basically it is a wiki but many more functionalities intagrated.
Who uses it and what for
= Employees. Knowledge Sharing, Preparation of collaborative-documents, etc.
Do you share information between projects / teams / departments or not?
= Depends on the requirements. It is possible to set permissions between users.
We use a wiki, for documenting our systems. It's updated gradually as things update and evolve. It should go without saying that there's benefit in that, however whether you use a wiki or other methods is worth thinking about.
A wiki is great for collarborative editing. The information shouldn't go stale in theory, because as people use the systems they have the opportunity to keep it up to date.
However we have found in our organisation that people struggle a little with wiki markup. Especially tables. I think a solution that has wysiwyg editing would be better if you have non-highly-technical people editing it. Sharepoint springs to mind, but it's expensive.
I use a wiki as my virtual "story wall" for agile development. All of my stories are written and organized in the wiki. While my customers are reasonably local (we can have face-to-face meetings), they aren't co-located. To enable better customer interaction I've resorted to a wiki instead of a wall-based story tracking mechanism. It also works a little better for me due to the fact that I often have multiple, concurrent projects and limited wall space in my cube. In a larger team with more focused projects and more wall area, I'm not sure I'd make the same choice.
My company uses a wiki for project-planing but also for storing documentation and ideas.
I have found that a wiki is a great way to link the programmers in the company with the business-people.
When someone who are not on the programming-team comes up with an idea or finds a bug, it's a loot simpler to let that person document it in the wiki.
I think it's an important aspect for a small company like mine to easily synchronize the business-team with the development-team. A wiki helps with that, since it gives the feeling of being a part of the development process, instead of having to ask the programmer directly about every little detail.
we have MediaWiki to store technical information that is not ready to be published in other formats - specification drafts, diagrams (via GraphViz extension), results of short investigations, etc.
I also think this question is a wiki too :)
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 9 years ago.
Improve this question
I was recently put in charge of the wiki for the development team. The wiki is still in its infancy, so I have a lot of room to work with. It goal is to house internal to the development team. Currently, the main piece of information that the wiki holds is Coding Standards.
What are some best practices your dev team uses for its internal wiki?
What information is important to have on a dev wiki?
If you were to go to the wiki for your dev team what information would you expect to see?
Is there some information that shouldn't go on the wiki even though it seems like a good idea?
-- edit --
Also, is there a good way to organize the information? ( such as by layer ( data, ui), by porject, or other)
Introduction to the source base for new programmers
General documentation (not the API documentation per-se, but more tutorial like things)
Lists of staff / who's doing what and how to reach them
Notes / resources / articles that explain concepts used in the software
Documentation of the build process and the filesystem layout of the codebase
Other things I usually put up there are
Planning / todo lists
Information that is interesting for others to read
Everything else that I feel should be shared
We had a development wiki and it was a great tool. We used it for everything!
When brainstorming new ideas, we'd capture them on the wiki. The low friction nature of the wiki made it easy for anyone in the organization (we were a small startup) to add ideas as they thought of them. We had a high level "brainstorming" page which linked to detailed pages containing a thorough description of each idea.
For each iteration, we'd "move" feature idea items from the "brainstorming" list to the feature list for that iteration. The details of the feature were flushed out to include design and implementation details.
As features were completed, the iteration page became our release notes page - which also included the release tag from our version control system.
We had a bug page that worked very similar to the feature pages. Bug fixes were added to the iteration/release pages as they were worked on/complete.
We also created our user documentation on the wiki and exported those pages it with the release.
As time went on. This tool was viewed more and more valuable. We wound up creating new wikis for different the products the company was working on.
I hope you find your development wiki as useful as we did!
Wikipatterns is a website dedicated to documenting best wiki practices. They also describe anti-patterns and talk about ways to deal with them. I read their book and it was a great asset for me to get a wiki off the ground in a 150+ person organization.
One thing that we stress on our dev wiki is that it is updated when things change.
We don't want our wiki that is intended to provide information and be a central source of collected knowledge to become so out of date that it is useless. As the code is updated, developers are requested to update any related information on the wiki.
Other than Coding Standards, we keep tips and tricks for working with our code base, setup information for new hires, and general environment information.
The hardest part is getting developers to use your wiki. I have some long standing suggestions here: http://possibility.com/wiki/index.php?title=GettingYourWikiAdopted
Getting a Wiki Adopted is Tough
Have a Champion
Remove Objections
Create Content
Enmesh the Wiki In Company Processes
Evangelize
Don't Give Up
Consider Not Using Wiki For Conversations
Just Do It! Don't Wait For a Budget
Have a Transition Plan
Promoting Your Wiki
One good practice is to have the entire documentation and source code for each build available through your wiki. Then developers will go to wiki to access build info and that makes it invaluable.
Wikis can be a valuable resource for software development teams but they are not a silver bullet. It is all too easy to create a Wiki that would rapidly fall into disuse or become grossly outdated.
In my opinion, the key to a successful Wiki is getting the entire team on board. That means getting people away from other resources (and in particular email archives) as knowledge repositories, and offering some incentive for people to contribute.
However, it's also important to not be a format czar: If you have a lot of documents that you generate in, say, MS WORD, it may be ideal to do them all in Wiki format but that takes time and may be annoying if you have diagrams, documents, etc. In those cases, it's better to compromise and let people keep it in word format, as long as the only way to access the newest version is through the Wiki.
If you're not a manager, you need to get a manager on board because it would require some "enforcement".
There has been accumulating research and experience on Wikis and their use in software engineering. You can search the ACM digital library, for example. I am a coorganizer of an annual workshop on wikis for SE and we had several interesting experience reports and there are additional materials in the international symposium on Wikis.
Burndown charts
common setup information for development environments (nice for when new people start)
Specs
Known issues and workarounds with development tools
Come up with some kind of style guide, and teach others how to style stuff. When I was in charge of a corporate wiki, all of the other developers would just write crummy prose that was barely formatted, and looked terrible.
Keep away from things that require discussion. I tried shoehorn in a book review section, but it was too difficult to have others comment on things.
Examples of in house libraries are good. And/or "storyboards" walking a user through a process when MethodX is called.
What are some best practices your dev team uses for its internal wiki?
Make it look nice. I know it doesn't sound important, but if you spend a little time branding it pays off in terms of people actually using it. And uptake is key, or it will just wither and die.
What information is important to have on a dev wiki?
General information about a Project, milestones, delivery dates etc.
Summaries of design decisions/meetings. Important so that you don't re-visit the same areas time and time again.
HowTo guides for general development of current projects (for example, how to develop a new Plugin)
If you were to go to the wiki for your dev team what information would you expect to see?
Project information, who is working on what etc. Design decisions. Also best practices and links to useful sites.
Is there some information that shouldn't go on the wiki even though it seems like a good idea?
Low-level task lists tend to fluctuate and not be kept up-to-date, and can be misleading.
Also, critical communications between departments are better suited to e-mail, THEN the conversation can be copied to the wiki. It's too easy to ignore it otherwise!
Remember that a wiki is interactive. If you're thinking about publishing, as in publishing burndown charts, then you're not thinking far enough. Distributing that information is only part of it.
For instance, rather than having a "Current Burndown Chart" page, create a page for "Burndown Chart for Week of 10-27-2008" and then encourage people to comment on the chart, and what it means, and why you did so poorly that week.
We house and inhouse team wiki. And there we put all the necessary information for each project we are developing:
repositories
addresses for virtual machines
passwords
project documentations
project overview
project status
and anything else we fill needs to be written on a project. And it is the most useful web application we are running (besides Mantis) . On more general pages we put a definition of every taxonomy we are using, general project guidelines, polices, coding and developing practices we use.
It is there, it is simple and effective and I think every team should have one of those.