Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 9 years ago.
Improve this question
Unfortunately I'm not familiar with UML (yet) and I don't know what validations are in place in the standard tools. But after reading this it seems validation is missing so I ask SO for advice.
I want it to find stuff like
logical inconsistencies
disconnected parts (islands)
unreachable parts (for example a state with only from transitions)
missing cases (a item is defined with 3 transitions but only 2 is used)
Other things I don't know about but someone used to UML would want.
If you use Visual Studio, you might try the RC release of VS 2010 Ultimate. You can generate dependency graphs for .NET code to find disconnected or unreachable code. You can create layer diagrams from dependency graphs or from existing artifacts, draw the permitted dependencies, and then use layer validation to make sure invalid dependencies aren't introduced. This version also includes 5 UML diagrams: class, component, sequence, use case, and activity.
How to: Generate Graph Documents from Code: http://msdn.microsoft.com/en-us/library/dd409453%28VS.100%29.aspx#SeeSpecificSource
You can use Visual Studio Ultimate to explore the relationships and organization in existing code by
generating directed graph documents. These graphs represent code elements and their relationships
as a set of nodes that are connected by links, or edges. You can use these graphs to help you
visualize, explore, and analyze code.
How to: Find Code Using Architecture Explorer: http://msdn.microsoft.com/en-us/library/dd409431%28VS.100%29.aspx
You can select vertical sections or "slices" of code that you want to visualize by using
Architecture Explorer. You can explore source code in a Visual Studio solution or
compiled managed code in .dll files or .exe files. You can use Architecture Explorer to browse
other domains by installing additional providers. When you find the code that you want to
visualize, you can generate graphs to explore the relationships in that code.
How to: Create Layer Diagrams from Artifacts: http://msdn.microsoft.com/en-us/library/dd465141%28VS.100%29.aspx
...use layer diagrams to visualize the high-level architecture of your system and to verify that
the code complies with this design. To perform this task, organize and associate the
artifacts from a Visual Studio solution into logical, abstract groups, or layers. These layers
describe major tasks that these artifacts perform or the major components of your system. Arrows
between the layers represent the interdependencies that exist or should exist between these
artifacts. To enforce architectural constraints on the code, describe the intended dependencies on
the diagram and then validate the code against the diagram. By using layer diagrams in this
manner, you can help make the code easier to understand, reuse, and maintain.
Layer Diagram http://i.msdn.microsoft.com/Dd465141.UML_LayerRefReading(en-us,VS.100).png
How to: Validate Code Against Layer Diagrams: http://msdn.microsoft.com/en-us/library/dd409395%28VS.100%29.aspx
Validating code against a layer diagram helps you enforce architectural constraints on the code
as it evolves. When you perform this task, dependencies in the code are compared with dependencies
on the diagram.
RC download: http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=457bab91-5eb2-4b36-b0f4-d6f34683c62a.
Visual Studio 2010 Architectural Discovery & Modeling Tools forum: http://social.msdn.microsoft.com/Forums/en-US/vsarch/threads
No, I'm not aware of any UML tools that do these things. I've done a fairly recent survey of tools for my employer, and I didn't see any such features.
You realize, of course, just what a high level of functionality you're asking for. You write as if you expect these to be common.
Sparx Enterprise Architect does a lot of those validations. I don't know if it does all of them.
I could point to some research prototype tools, specially for the verification and validation of class diagrams with or without OCL constraints (e.g. my own verification tool http://gres.uoc.edu/UMLtoCSP/ or http://www.db.informatik.uni-bremen.de/projects/USE/) but
these are tools are just that: research tools (with all the limitations this implies).
I'm not really aware of any commercial CASE tool that offers advanced verificacion/validation capabilities.
Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 8 years ago.
Improve this question
I have tried using ProR to create an ReqIF document. It is cumbersome and contains a lot of bugs, since it is in its alpha state now. Another constraint that I have right now is that I cannot use proprietary software like IBM Rational DOORS. Are there any other such tools to generate ReqIF documents? Are there any alternatives to ProR?
I am the project lead on the Eclipse ProR project, and I am sorry to hear that ProR is not yet up to it for your needs.
As far as I know, there is not even commercial support for ReqIF available (please correct me if I am wrong). DOORS currently only supports RIF 1.2. Also, please keep in mind that ReqIF 1.0.1 only got released in April 2011 - that's not even a year. It takes time to write software. :-)
A possible alternative for you may be to use a RIF tool and to write yourself an XSLT script to transform RIF into ReqIF.
Another alternative is to work with RIF 1.1 or RIF 1.2 for the time being. There are many commercial tools supporting that standard, although I am not aware of a single one that is free.
The third (and to me preferred) option would be if you could give ProR another chance, and help to improve it. Specifically, if you could give us clear, reproducible bug reports, that would be fabulous. Also, it would be incredible useful if we knew how you plan on using ProR (what are your use cases?). We are actively working on ProR right now, and respond fairly quickly.
Here is the link to file a ProR Bug in Bugzilla
The best place to discuss usage and use cases is the RMF Forum
And last, for reference, the ProR project web page
Shriram,
RIF 1.2 files generated in DOORS 9.x do not conform to the schema - that's at least what we have experienced at a customer site.
If you want to transform RIF 1.1a, 1.2 or XLS to ReqIF (and vice-versa), you might want to try http://www.pyrrho.com/en/ReqIF/ReqIF-Intro.htm. They run an online conversion service, which is currently free - I do not know what the future plans are.
I have heard from a colleague that the User Interface of Pyrrho is not quite intuitive, but I have tried it and it works. The XLS to RIF/ReqIF transformation is still limited, as all datatypes are interpreted as strings, so far. It is generated from the models, so it should be complete, otherwise.
Our tool, the ReqIF Server (http://www.reqif.de), is free for university projects, but not complete enough to create a reqif file from scratch. You can edit existing ones, though. Or convert RIF 1.1a to 1.2 and vice versa.
Best regards, Oskar
I am project member of the ERA ReqIF editor.
We have implemented an EMF/Ecore representation of a subset of the ReqIF model.
Still, we store files primarily in EMF XML format.
Our little converter to ReqIF XML format is yet a prototype and very alpha (because we focus on our user-configurable GUI...).
In conclusion, ERA will not help you, yet. But I just wanted to let you know.
Probably you are interested in tracking our project in the future.
(We are a small private team and it will take us some time.)
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 7 years ago.
Improve this question
My application is reaching a pretty nice beta/alpha level and I might at some point publish it. I have not decided what software license to use in my application. The application is under construction. I bet this must be a question that every developer thinks about at some point.
My software is more like a library and here are some key factors in my case:
It must be an open-source license.
It must be free for developers to use as a library for their applications.
Developers are allowed to redistribute the source code as part of their applications modified or unmodified.
The library can be used for closed-source software.
I want attribution/credit. A one-line credit in the software Help dialog or somewhere in about section of their website is fine. As long as it is reasonable easy for a 3rd-party to find out what library was used to produce the resulting software.
Forking a new project out of my existing source code should not be allowed. I want people to be able to use it and even modify it, but not clone a new similar product to compete against my existing product.
The license needs to state that I take no responsibility for any damage whatsoever.
Is there such a license? Would those requirements even fit in an open-source license?
Forking a new project out of my existing source code should not be allowed
Above is in conflict with Open Source idea (which allows/encourages forking). More info here: Which open source license has no forking
If you think that you can drop that requirement the best choice is LGPL and additional requirement that people must give you credit (you will have to define what type of attribution/credit do you want per different uses)
As James stated in previous comment:
Forks very rarely happen
It is very hard to fork a (big) project
You can benefit more if there are forks - you can take the good ideas from the fork and leave the bad. That way the better judgement about features/code will eventually win (which is part of the idea of Open Source)
Forking a new project out of my
existing source code should not be
allowed. I want people to be able to
use it and even modify it, but not
clone a new similar product to compete
against my existing product.
Ummm ... This is I have never heard of in a Open Source license, and I don't know of any that have this. How would you even word it? Determining the difference between a fork and someone else who has taken your code and just added a patch would be really hard.
Can you think about this one? Forks very rarely happen, and when they do they aren't always competition. Talent, ideas and even code can flow between the forks freely.
You need to speak to a lawyer, we aren't lawyers and don't know your application.
Prevention of forking with open source licenses is complicated, as James says.
For commercial applications, you may want to look at dual licensing.
As far as I know the LGPL allows forks.
You should be able to find one to suit your needs here:
http://en.wikipedia.org/wiki/Comparison_of_free_software_licenses
More specifically I think the GPU Lesser Public License might suit the needs of your library. Keeping in mind that like (all?) open source licenses, LGPL allows forking.
http://en.wikipedia.org/wiki/GNU_Lesser_General_Public_License
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 7 years ago.
Improve this question
My question is in regard to referencing open source frameworks. There are many of them for many different purposes. I personally leverage several of them in a single project. For example:
Unity
CAL/Prism
ValidationAspects
EnterpriseLibrary Logging
EnterpriseLibrary Exception Handling
EnterpriseLibrary Caching
Caliburn
All of these frameworks have helped greatly from a development effort perspective. There are however some negative aspects involved:
Tons of dlls (15 from the above list).
Application level (non-common assemblies and new assemblies) must reference many core dlls, which can be confusing) and tons of different namespaces are involved.
Deployment of said tons of dlls can get problematic (I sometimes use ILMerge to alleviate this and the above problems, but let's put that aside for now).
Open source project lifetime - open source projects come and go, so if any of these become no longer actively maintained, it can be concerning if there are internal bugs that need fixing or enhancements we want.
Obfuscation of "how to do things". We don't actively leverage every part of the above frameworks. In fact, several of these frameworks have overlap and provide redundant components and functionality. In terms of development, this can be confusing. We want a consistent implementation that is straightforward and easy to understand across our code base. Having multiple areas that do the same thing in different ways can be troublesome in this respect. This is probably one of my biggest concerns.
You're in big trouble if these frameworks reference different versions of other assemblies (ie. one internally references Unity 1.1 and another Unity 2.0).
The alternative? Include the source code in a common dll for your project(s) (ie. MyProject.Common). Let's put aside the issue of adherence to license requirements for the time being.
This has several negative implications too:
It's not as easy to leverage updates released by the framework's provider - you need to update your source code.
Encapsulation of functionality - it's easier to break this paradigm when the source code is all in your hands.
So, I know people probably have lots of opinions on this...and I'd like to hear them.
Thanks.
For some aspects of your problem, this might be relevant: http://en.wikipedia.org/wiki/DLL_hell#Running_Conflicting_DLLs_Simultaneously.
Another common solution to this problem is to write an encapsulation layer on top of the functionality needed, which at least protects your code from wild changes when upgrading to new versions of supporting libraries.
As to open source project lifetime, it should be clear which projects are healthy and which are not. For example, a project that is part of the Apache or Eclipse foundations are probably healthy, whereas some random thing on sourceforge is probably not. Generally, you can avoid this problem altogether by avoiding projects that do not seem active.
For the negatives to copying code into your project:
I know you wanted to put license aside, but you cannot in reality. I am not a lawyer and you should consult with one for your project if there may be issues, but if you are developing a proprietary system it could become GPL'ed accidentally.
It makes your development environment more cluttered. You have to worry about making sure the copied-in code ompiles properly, is being compiled with the right version, and has the right build scripts. You also have all this extra code in your IDE that takes up space.
As you pointed out, it makes updating code very difficult.
If you have to file bugs with the Open Source project, it becomes more difficult to do.
If you're not careful, a junior developer who doesn't know any better could go into the code and start mucking around with it.
There's probably more reasons not to do it, but that's a few. Hope that helps.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a book, tool, software library, tutorial or other off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 8 years ago.
Improve this question
does anyone know about a open source expert system? actually, I'm rather interested in calling its inferential engine from C#.
Both CLIPS and JESS are already mentioned in other answers, so I will supply this link to CLIPS versus JESS:
http://www.comp.lancs.ac.uk/~kristof/research/notes/clipsvsjess/
It was written June 4, 1999, and at that time the advantage was clearly with CLIPS.
If you don't want to read it all, here are the conclusions:
Chapter 3 The conclusions
Both CLIPS and JESS are products with a large support on the internet,
but CLIPS seems to have a broader audience, probably because it exists
longer. This difference in age results in the CLIPS package being more
stable and complete, while JESS users will still experience some minor
bugs. JESS is constantly updated and the author, Ernest Friedman-Hill,
has been very responsive to user/developer feedback and regularly puts
out new releases and bug fixes.
Nowadays, the choice between JESS and CLIPS depends on the
application. If it is web-based or should reside in applet-form, the
choice of JESS is a very logical one (which is even supported by the
authors of CLIPS). For the more classic applications, CLIPS will
probably be chosen because of its reputation of being more stable and
having more support.
The future of JESS depends highly on the evolution of the web, the
Java programming language and its own future stability. These three
conditions make that there is a great possibility that JESS will
become more popular and more frequently used. Especially the
object-oriented possibilities and the easy integration into Java code
makes JESS’ future very promising.
CLIPS, on the other hand, is more likely to implement the new and
sophisticated features first as they come out, since it still has the
advantage in time. CLIPS has also various extensions and variants(like
FuzzyCLIPS, AGENT CLIPS, DYNACLIPS, KnowExec, CAPE, PerlCLIPS, wxCLIPS
and EHSIS to name a few) that give it an advantage with respect to
support of methods like fuzzy logic and agents.
The multifunctional developing environment of CLIPS for operating
systems that support windows is also an advantage, while JESS has just
one window with two buttons (‘clear window’ and ‘quit’), without a
menu. Figures 1 and 2 depict both environments.
To summarize, CLIPS is still more complete and stable than JESS, but
this might change in the future, since the JESS package is being
improved constantly. Besides that, JESS has also the property of using
Java, which in the long run might prove to be a big advantage over
CLIPS.
These links may also be of interest:
http://en.wikipedia.org/wiki/CLIPS
Commercial & Freeware Expert System Shells
http://www.kbsc.com/rulebase.html
Are there open source expert systems with reasoning capabilities?
I went through the same process, about a year ago, trying to find a good .Net system for this. I recall finding a few decent engines, but they were all too general, and required too many assumptions.
In the end I found that writing my own system was pretty easy to do, and it did exactly what I wanted it to, without any extra bull to make it work with some abstract generalized engine.
It might help to know what your intended use is.
Take a look at CLIPS -- it is coded in C.
There's more info on CLIPS at Wikipedia.
If you'd consider a rule-processing engine, JBoss Rules (also known as Drools) is the best that I know of. Open Source and free. It's written in Java, but designed for integration. You can incorporate objects in the rules and rule-base applications in your components. You can even build or modify rule-bases on the fly.
AI::ExpertSystem::Advanced or AI::ExpertSystem::Simple is a Perl solution.
You can try JESS, but it is Java-based. Amzilogic also provide a good platform.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 4 years ago.
Improve this question
In the course of your software development lifecycle, what essential design artifacts do you produce? What makes them essential to your practice?
The project I'm currently on has been in production for 8+ years. This web application has been actively enhanced and maintained over that time. While we have CMMI based policies and processes in place, with portions of our practice being well defined, the design phase has been largely overlooked. Best practices, anyone?
Having worked on a lot of waterfall projects in the past and a lot of adhoc and agile projects more recently, there's a number of design artifacts I like to create although I can't state enough that it really depends on the details of the project (methodology/team structure/timescale/tools etc).
For a generic, server-based 'enterprise application' I'd want the bare minimum to be something along these lines:
A detailed functional design document (aka spec). Generally something along the lines of Joel s' WhatsTimeIsIt example spec, although probably with some UML use-case diagrams.
A software techical design document. Not necessarily detailed for 100% system coverage but detailed in all the key areas and containing all the design decisions. Being a bit of an UML freak it'd be nice to see lots of pictures along the lines of package diagrams, component diagrams, key feature class diagrams, and probably some sequence diagrams thrown in for good measure.
An infrastructure design document. Probably with UML deployment diagram for the conceptual deisng and perhaps a network diagram for something more physical.
When I say document any of the above might be broken down into multiple documents, or perhaps stored on a wiki/some other tool.
As for their usefulness, my philosophy has always been that a development team should always be able to hand over an application to a support team without having to hand over their phone numbers. If the design artifacts don't clealry indicate what the application does, how it does it, and where it does it then you know the support team are going to give the app the same care and attention they would a rabid dog.
I should mention I'm not vindicating the practice of handing software over from a dev team to a support team once it's finished, which raises all manner of interesting issues, I'm just saying it should be possible if the management so desired.
Working code...and whiteboard drawings.
:P
Designs change so much during development and afterwards that most of my carefully crafted documents rot away in source control and become almost more of a hindrance than a help, once code is in production. I see design documents as necessary to good communication and to clarify your thinking while you develop something, but after that it takes a herculean effort to keep them properly maintained.
I do take pictures of whiteboards and save the JPEGs to source control. Those are some of my best design docs!
In our model (which is fairly specific to business process applications) the design artefacts include:
a domain data model, with comments on each entity and attribute
a properties file listing all the modify and create triggers on each entity, calculated attributes, validators and other business logic
a set of screen definitions (view model)
However do these really count as design artefacts? Our framework is such that these definitions are used to generate the actual code of the system, so maybe they go beyond design.
But the fact that they serve double duty is powerful because they are, by definition, up to date and synchronised with the code at all times.
This is not a design document, per se, but our unit tests serve the dual purpose of "describing" how the code they test is supposed to function. The nice part about this is that they never get out of date, since our unit tests must pass for our build to succeed.
I don't think anything can take the place of a good old fashioned design spec for the following reasons:
It serves as a means of communicating how you will build an application to others.
It lets you get ideas out of your head so you don't worry about tracking a million things at the same time.
If you have to pause a project and return to it later you're not starting your thought process over again.
I like to see various bits of info in a design spec:
General explanation of your approach to the challenge at hand
How will you monitor your application?
What are the security concerns and how are they addressed?
Flowcharts / sequence diagrams
Open issues
Known limitations
Unit tests, while a fantastic and arguably critical item to include in your application development, don't cover all of these topics.