I'm making a window showing all available plug-ins on the user's system. I want to group VST plug-ins to a visual bundles with common name in a one column and all available formats (like mono, stereo, etc.) in a separate column. Here is an example:
| TrueVerb | Mono, Stereo |
| UM226 | Stereo, 5.0, 5.1 |
I see ProTools does something similar. I think it is because AAX plug-ins have separate unique ids for product and instance that could be used for such sort of things. But VST and VST3 SDKs don't provide anything similar. Though VST SDK provide "product name" of plug-in instance, it is not included in VST3 SDK.
Is there a way to tell whether certain instances represent same algorithm (i.e. product) with different format (width), except for parsing a plug-in name?
Related
Our system is composed of a lot of different device types. Most of our software components are deployed on more than one device type.
In terms of diagrams, how do I represent the fact that one software component C is deployed both on devices D1 and D2? If I create a deployment diagram with devices D1 and D2, then:
Dragging C into D1 in the diagram will also move C into D1 in the Project Browser, and I want my software components not to be assigned to one device in particular
I am not allowed to drag C into the diagram more than once. How can I represent in the same diagram the fact that C is deployed both on D1 and D2?
You do that by creating instances. You have a package with components that represent a blueprint (like Acre PC X4711 which represents a general type). Now you Ctrl-drag that onto your deployment diagram for a certain location. Choose "As Instance" from the appearing pop up and eventually name the device (e.g. "John's PC"). Additionally you can assign tagged values for the serial number etc. It might be a good idea to create a MDG to assist you with that.
I want to do preprocessing of docs(wsdl files) using mallet in Eclipse. I want to generate feature vectors and perform classification using mallet and MaxEntropy. I am new in using mallet, Can anyone guide me in this regard.
Thanks
If you're referring to Web Services Description Language, I don't know of any specific workflows or packages designed for those documents. I suspect that you might want to create a set of features that combines text (from web service descriptions) and more "categorical" features, like URLs or URL patterns.
The way I would approach this problem is to create a separate package that reads WSDL files and writes out a file in a format that Mallet expects. This adapter could be written in whatever language you are most comfortable with. It would read all the files, get a parsed XML tree for each, extract text and certain other features, and output a file in Mallet's preferred tab-delimited, one-doc-per-line format.
I am implementing my first Spring-Batch application. In the naming of the packages, the Samples project names each domain in its own package with readers-writers-processors all in one package for the respective domain (i.e. football game). Is that typical?
Say, for example, I have jobs to read-process-write for 10 different flat files. Should I have 10 different packages with each package containing the readers-processors-writers for each respective file/job?
Or, could it be equally reasonable to have one 'readers' package for all the readers, and a 'processors' package for all the processors, and a 'writers' package for all writers.
I'm interfacing with an SAP system, and over time, the number of files we process will grow. So, I'm trying to get a smarter handle on what's better, in terms of naming and organizing my packages. And, I want to do it the way the Spring-Batch community would do it.
Thanks.
I would use the first solution,but perhaps adding an extra package for complex jobs containing many steps, for example: com.company.software.batch.jobName.stepName
Then you will have a clear functional view of all your jobs.
I have an object and I need to keep a history of all changes made to it. How would I implement this using neo4j?
As with a RDBMS, it would depend on your domain and data query requirements.
Does your application require regular access to all versions of the object or usually just to the most recent, with the older versions available via the current one? An example of this could be pages on Wikipedia. As as example, let's say we have a page which is on version 3. We could then model this as follows:
(pages)-[:PAGE]->(V3)-[:PREV]->(V2)-[:PREV]->(V1)
^ ^
| |
category current
node version of page
Here, only the current version can be seen to form part of the main structure but you may wish to allow all versions to form part of that structure. In this case, you could use relationship properties to indicate the version and have all page versions link from the category node:
(V1)
^
|
[:PAGE(v=1)]
|
(pages)-[:PAGE(v=2)]->(V2)
|
[:PAGE(v=3)]
|
v
(V3)
Here, you can immediately traverse to a particular version of the page by simply specifying the version in which you are interested.
A third option could be that you wish all older versions to be completely separate from the main structure. For this you could use multiple category nodes, one for (current_pages) and another for (old_pages). As each page is superseded by a new version, it becomes unlinked from the former category and instead linked to the latter. This would form more of an "archive" type of system where the older versions could even be moved into a separate database instance.
So you have these three options, plus more that I haven't thought of! Neo4j allows you great flexibility with this sort of design and there's absolutely no "right" answer. If none of these inspire you however, post a little more information about your domain so that the answer can be more tailored for your needs.
Cheers,
Nige
You could also approach it from the other side:
(pages)-[:VERSION]->(V1)-[:VERSION]->(V2)-[:VERSION]->(V3)
^ ^
| |
category current
node version of page
advantage : when you create a new version, you just add it at the end of the chain, no need to "insert" it between the (page) and the current version.
disadvantage :you can't just throw away old versions, unless you reconstruct the chain. But this is probably not a frequent operation.
I am currently in bureaucratic hell at my company and need to define what constitutes the different levels of software change to our test programs. We have a rough practice that we follow internally, but I am looking for a standard (if it exists) to reference in our Quality system. I recognize that systems may vary greatly between developers, but ultimately I am looking for a "best practice" guide to what constitutes a major change, a minor change etc. I would like to reference a published doc in my submission to our quality system for ISO purposes if possible.
To clarify the software developed at my company is used internally for test automation of Semi-Conductors. We are not selling this code and versioning is really for record keeping only. We are using the x.y.z changes to effect the level of sign-off and approval needed for release.
A good practice is to use 3 level revision numbers:
x.y.z
x is the major
y is the minor
z are bug fixes
The important thing is that two different software versions with the same x should have binary compatibility. A software version with a y greater than another, but the same x may add features, but not remove any. This ensures portability within the same major number. And finally z should not change any functional behavior except for bug fixes.
Edit:
Here are some links to used revision-number schemes:
http://en.wikipedia.org/wiki/Software_versioning
http://apr.apache.org/versioning.html
http://www.advogato.org/article/40.html
I would add build number to the x.y.z format:
x.y.z.build
x = major feature change
y = minor feature change
z = bug fixes only
build = incremented every time the code is compiled
Including the build number is crucial for internal purposes where people are trying to figure out whether or not a particular change is in the binaries that they have.
to enlarge on what #lewap said, use
x.y.z
where z level changes are almost entirely bug fixes that don't change interfaces or involve external systems
where y level changes add functionality and may change the UI/API interface in addition to fixing more serious bugs that may involve external systems
where x level changes involve anything from a complete rewrite/redesign to just changing the database structures to changing databases (i.e. from Oracle to SQLServer) - in other words anything that isn't a drop in change that requires a "port" or "conversion" process
I think it might differ if you are working on an internal software vs a external software (a product).
For internal software it will almost never be a problem to use a formally defined scheme. However for a product the version or release number is in most cases a commercial decision that does not reflect any technical or functional criteria.
In our company the x.y in an x.y.z numbering scheme is determined by the marketing boys and girls. The z and the internal build number are determined by the R&D department and track back into our revision control system and are related to the sprint in which it was produced (sprint is the Scrum term for an iteration).
In addition formally defining some level of compatability between versions and releases could cause you to very rapidly move up or to hardly move at all. This might not reflect added functionality.
I think that best approach for you to take hen explaining this to your co-workers is by examples drawn from well known and succesful software packages, and the way they approach major and minor releases.
The first thing I would say is that the major.minor dot notation for releases is a relatively recent invention. For example, most releases of UNIX actually had names (which sometimes included a meaningless number) rather than version numbers.
But assuming you want to use major.minor, numbering, then the major number indicates a version that is basically incompatible with much that went before. Consider the change from Windows 2,0 to 3.0 - most 2,0 applications simply didn't fit in with the new overlapped windows in Windows 3,0. For less all-encompassing apps, a radical change in file formats (for example) could be a reason for a major version change - WP &n graphic apps often work this way.
The other reason for a major version number change is that the user notices a difference. Once again this was true for the change from Windows 2.0 to 3.0 and was responsible forv the latters success. If your app looks very different, that;s a major change.
A for the minor version number, this is typically used to indicate a chanhe that actually is quite major, but that won't be noticeable to the user. For example, the differences internally between Win 3.0 and Win 3.1 were actually quite major, but the interface stayed the same.
Regarding the third version number, well few people know hat it really means and fewer care. For example, in my everyday work I use the GNU C++ compiler version 3.4.5 - how does this differ from 3.4.4 - I haven't a clue!
As I said before in an answer to a similar question: The terminology used is not very precise. There is an article describing the five relevant dimensions. Data management tools for software development don't tend to support more than three of them consistently at the same time. If you want to support all five you have to describe a development proces:
Version (semantics: modification)
View (semantics: equivalence, derivation)
Hierarchy (semantics: consists of)
Status (semantics: approval, accessibility)
Variant (semantics: product variations)
Peter van den Hamer and Kees Lepoeter (1996) Managing Design Data: The Five Dimensions of CAD Frameworks, Configuration Management, and Product Data Management, Proceedings of the IEEE, Vol. 84, No. 1, January 1996