i'm currently preparing the srs documents for a project , i wounder how these documents and flow charts are transformed to classes , packages and functions?
any suggestion to books or tutorials that explain this transformation process ?
What you might looking for is called "Object Oriented Design".
This generally describes the process of modeling classes and structures out of real world or business objects (described in your specification).
This is quite a wide topic, but as a good starting point I would recommend the book
Object-Oriented Analysis and Design.
For some other suggestions see this question.
Related
I created my own R-Tree and I would like to add it to PostgreSQL, I was reading about PostGis, However I don't kwow exactly How can I do that.
R-Tree is implemented in PostgreSQL as GiST index for two-dimensional geometric data types. To add your own implementation you should consider using GiST infrastructure too. Citing the documentation:
Traditionally, implementing a new index access method meant a lot of difficult work. It was necessary to understand the inner workings of the database, such as the lock manager and Write-Ahead Log. The GiST interface has a high level of abstraction, requiring the access method implementer only to implement the semantics of the data type being accessed. The GiST layer itself takes care of concurrency, logging and searching the tree structure.
So, first read this chapter to make sure you understand the concepts of index methods, operator classes and families.
Then, read about GiST index and its API. There you can find useful examples that will help you.
Also, a lot of helpful information you can find on development section of PostgreSQL site.
Any programming questions you may address to PostgreSQL developer's mailing list.
I see that you can use datastore to hold key value pairs, process data in chunks, and pass it to mapreduce. Does this mean that the datastore object in Matlab is like a NoSQL database? If not, how does it differ?
In case of any ambiguity about what characterises a NoSQL database, I am considering as a starting point these characteristics obtained from dba.stackexchange: https://dba.stackexchange.com/a/25/35729
You'll find that NoSQL database have few common characteristics. They
can be roughly divided into a few categories:
key/value stores
Bigtable inspired databases (based on the Google Bigtable paper)
Dynamo inspired databases
distributed databases
document databases
In Matlab you can always import java Classes and use any java library, (with the one difference that there is no multithreading). So typically you won’t find many libraries written in matlab that do the same thing as a java library for this reason. In general I would also say it’s harder to write a library in matlab which may be a factor for the lack of libraries as well.
I think your only option is to use a java library, IMHO is a much better choice anyway because java is so much more popular to programmers working with databases, it will always have better libraries which are maintained. The one drawback is that you can’t implement java interfaces in matlab (correct me if I’m wrong). This can become a massive pain.
So not really, here is a Mongo examples on github https://github.com/HanOostdijk/matlab_mongodb
I know that the NoSQL is not the relational database therefore I cannot draw the ERD or other method which can only be applied to relational database.
My confusion is: What kind of method or diagram should I illustrate to design a NoSQL database?
Thanks.
Here's an abstract from a recent 10gen event presentation suggesting that mind maps are the most logical tool for the job. I expect more specialized tools to emerge, but in general, mind maps align well with non-relational schema design.
"Most of us are visual learners. Often, visual learners will find that information "clicks" when it is explained with the aid of a chart or picture. For MongoDB that picture is a leaf representing a natural approach to databases. In the RDBMS world a database schema is "visualized" through an Entity Relationship (ER) diagram. An ER diagram is the primary communication tool about an RDBMS data model. MongoDB provides a powerful dynamic database schema. However it is sometimes difficult to visualize. An accurate visualization of a MongoDB schema dramatically increases the ability to communicate the flexibility and power MongoDB between developers, architects, DBAs and end users. A mind map is a visual thinking tool that helps structure information, do better analysis, comprehend, synthesize and generate new ideas. Its power lies in its simplicity, much like MongoDB. Using a mind mapping open source tool, a clear and vibrant visualization of a dynamic MongoDB schema can be created that "clicks." Further, it works the other way around - mind maps can be used to create a dynamic schema in MongoDB. The mind mapping process allows non-technical business users to visually develop their requirements on the fly. During design process the mind map provides a flexible visual tool which changes in a fluid manner."
You can fairly easily use the standard tools however it depends upon your specific scenario and the problem you are looking to solve. I recently had a conversation about this actually: https://groups.google.com/forum/?fromgroups=#!topic/mongodb-user/xZCwEm06eU4 which might help however that conversation is also quite specialised.
I have been thinking ever since that instead of repeating myself on this I should actually write a manual for drawing UML diagrams, MongoDB style.
Maybe if you explain your perspective on what UML diagram you wish to draw then we could provide a more detailed answer on how to accomplish a type of NoSQL representation of them.
I'm looking for a little assistance in Scala similar to that provided by pyTables. PyTables is a package for managing hierarchical datasets and designed to efficiently and easily cope with extremely large amounts of data.
Any suggestions?
I had a quick look at pyTables, and I don't think there's anything remotely like it in Scalaland (or indeed Javaland), but we have a few of the ingredients necessary to make it a possibility if you want to invest the time:
scala.Dynamic to do idiomatic selection on data-driven structures
A bunch of graph databases to provide the underlying navigational persistence substrate (I've had acceptable results from OrientDB, which has a better license than most)
PyTables is a python implementation of HDF5 with some added niceties to let you work on it in a pythonic way, and get good indexing support. I'm not sure if there's a package implemented in a similar way in Scala, but you can use the same HFD5 based hierarchical data storageusing the HDF5 implementation in Java: HDF Java
As a personal project, I'm looking to build a rudimentary DBMS. I've read the relevant sections in Elmasri & Navathe (5ed), but could use a more focused text- something a bit more practical and detail-oriented, with real-world recommendations- as E&N only went so deep.
The rub is that I want to play with novel non-relational data models. While a lot of E&N was great- indexing implementation details in particular- the more advanced DBMS implementation was only targeted to a relational model.
I'd like to defer staring at DBMS source for a while if I can until I've got a better foundation. Any ideas?
First of all you have to understand the properties of each system. i can offer you to read this post. it's the first step to understand NOSQL or Not Only SQL.Secondly you can check this blog post to understand all these stuff visually.
Finally glance at open source projects such as Mongodb, Couchdb etc. to see the list you can go here
Actually, the first step would be to understand hierarchal, network, navigational, object models which are alternatives to relational. I'm not sure where XML fits in i.e. what model it is. As far as structure, research B-tree (not binary trees) implementation.