I was reading Applying UML and Patterns.
In the FURPS+ section, I read this one for +:
Operations - system management in its operational setting.
I just can't understand this sentence and I can't map it to a non-functional requirement.
I would be appreciated if anyone could help me with it.
and another question:
as far as I know, the + part of FURPS+ is different in other sources. so what's the point of it? I think it's not clear enough.
as I read more, the book gives an example:
operational concerns (for example, how do errors get handled, or how often
to do backups?)
but the second question still remains...
Related
I have two feature files feature1.feature and feature2.feature. In feature1.feature, I am creating a field value and adding it to FeatureContext.Current. Is there any possibility of accessing that value from feature2.feature?
I know that FeatureContext class will get cleared once the particular feature run is got over. Is there any other method for accessing values between two different feature files?
Please suggest some ideas.
Thanks in advance.
I would strongly advice against that setup. There's a couple of reasons for that:
The technical reason: SpecFlow doesn't guarantee the order it runs either features of scenarios. You cannot trust it to always be the same.
The business reason: The scenarios you're writing are first and foremost a communication tool. You want them to be easy to understand by themselves. When you talk about a particular scenario you shouldn't have to read through the other scenarios in the feature in order to understand what this special case does. It clogs up your communication around the scenario.
I suggest that you rather duplicated information in each scenario for readability. Should you end up with a lot of repeated information in each scenario you can you the Background-feature of Gherkin. These steps are run once before every scenario in the feature file and can be used to do repeated stuff.
Should you find yourself in a situation where you need to pass information back and forth between scenarios you should probably take a step back and reconsider your scenarios. Are these two different scenarios, really? Or is it maybe just one? How could you express them clearer?
I hope this was useful.
I never tried it, but maybe you can use the [BeforeFeature] and [AfterFeature] attributes to get the value from the featurecontext and set it in the the context of the next feature.
I am new to UML modelling and I was creating this use case and generalised the use cases into 4 main categories - Add info, View info, edit info and delete info. Each generalisation contains 6 use cases so in total it gives about 28 use cases and its difficult to fit them all in one system boundary whilst making it easy to understand. Can someone please advise please advise how I can overcome this?
Below is what i have so far. I have yet to add EditInformation and DeleteInformation but i've run out of space.
Many thanks
Use-cases are the description of the highest level behavior of the system. You shouldn't dwell into the lower level details. Normally, a system would have no more than several use-cases. According to your description, your actual use-cases are what you classified as categories: Add info, View info, Edit info and Delete info. Finer details such as ViewCar or AddBooking belong to the corresponding sequence/activity diagrams.
You can set for yourself a limit of how many artefacts you would put on a diagram at maximum. For example, you might say that all diagramms shall fit on a certain standard page format when printed. Typically, it is not the purpose of abstracting the use cases to a level where they all fit on one diagram but reveal no added value any more. You'd end up in a use case chart for a space rocket merely saying nothing but "launch spacecraft". Instead, try to identify such use cases on a highly abstract level and then you break them down into more detailed ones on subordinate diagrams. In most modeling tools you can create links between several diagrams. If you'd like to read more, I'd recommend Alistair Cockburn's standard book on use cases, ISBN 978-0201702255
Where can I find a well-written, in-depth technical discussion about "private URLs" like the ones used in Google Docs' "anyone with the link" sharing setting? I'm looking for topics like the algorithm and implementation for generating a link, the size of the ID space it uses, analysis of the security implications, and pragmatic compromises in security for convenience. I want to avoid reading dogma about "security through obscurity".
I found one loosely related Stack Overflow question, but it doesn't treat the topic in much depth, and the answers are more dogmatic and less pragmatic than I'd like.
I searched Google Scholar for "anyone with the link", "secret URL", and "private URL". I found a few interesting papers and patents, but I'm still interested to learn more about what the state of the art is.[1] [2] [3] [4] [5]
I suspect the lack of response to this question is primarily a reflection of the fact that 1) the problem space is highly nuanced and 2) the people that have solved it before don't feel like talking about what they have done. I'll try to buck the trend. :)
Pragmatically, the following variables tend to dominate conversations I've seen:
If a user has the link in hand and fwds it to friends, is this a feature or a bug?
If the content owner wants to revoke access (ie revoke the link), how easy should this be to do? How frequent of an occurrence is it?
Should the link time out? If so after how long?
Where is "the line" in our comfort here? For example, if it is a link to a document, is read only good enough? Should it be read-write capable? Is there a limit to our comfort given the threat model?
Is there a limit to the # of times the link should be usable?
Do we care if the links are pretty or can they have some ugly huge blob in them?
What sorts of concerns exist wrt versioning of the links, the back-end services, and things that might cause breaking changes?
If the underlying content moves / links change, should the private links that have been sent out break? More generally, what sorts of operations should break the links, and what user experience impact should that have?
Assuming a highly skilled attacker is after your links, what other defenses exist to prevent guessing against the space, and what instrumentation story do you have? You then overlay this with the math in the links themselves and convince yourself you have a threat model where it takes to guess a singular link, and with a cost model such that it is egregious expensive.
In terms of implementations, I'm not aware of papers or off-the-shelf implementations that do this. Every one I've been a part of (sadly, I've been a part of more than one...) have been custom.
I could propose a singular set of trade-offs and comment on them here, but I'm not sure it would be helpful. Everyone would answer the questions above differently.
I'm happy to comment more on your particular scenario with more data...
How can I link to the documentation of functions, structures and classes on MSDN in a persistent manner?
Microsoft appears to break the links every few months for no good reason and I haven't come across a method to refer to the topics in a way that - for example - points to the latest version of the documentation always. Is there such a way?
Edit: what I am looking for is a way to "permalink" a certain piece of documentation without having to worry about it disappearing. Preferably those names should be meaningful as well, instead of the usual combination of letters and digits followed by .asp or .aspx, such as: http://msdn.microsoft.com/en-us/library/ms923723.aspx.
NB: I realize that, even though this relates to programming, it may not be suitable for SO, so feel free to suggest moving it to a more appropriate SE site.
Please give an example. The links don't actually break that often.
For instance, http://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.aspx will never break, but http://msdn.microsoft.com/en-us/library/system.net.httpwebrequest(v=vs.110).aspx is specific to the version.
I wonder what sort of things you look for when you start working on an existing, but new to you, system? Let's say that the system is quite big (whatever it means to you).
Some of the things that were identified are:
Where is a particular subroutine or procedure invoked?
What are the arguments, results and predicates of a particular function?
How does the flow of control reach a particular location?
Where is a particular variable set, used or queried?
Where is a particular variable declared?
Where is a particular data object accessed, i.e. created, read, updated or deleted?
What are the inputs and outputs of a particular module?
But if you look for something more specific or any of the above questions is particularly important to you please share it with us :)
I'm particularly interested in something that could be extracted in dynamic analysis/execution.
I like to use a "use case" approach:
First, I ask myself "what's this software's purpose?": I try to identify how users are going to interact with the application;
Once I have some "use case", I try to understand what are the objects that are more involved and how they interact with other objects.
Once I did this, I draw a UML-type diagram that describe what I've just learned for further reference. What happens after depends on the task I've been assigned, i.e. modify the code, document the code etc.
There is the question of what motivation do I have for learning the new system:
Bug fix/minor enhancement - In this case, I may focus solely on that portion of the system that performs a specific function that needs to be altered. This is a way to break down a huge system but also is a way to identify if the issue is something I can fix or if it is something that I have to hand to the off-the-shelf company whose software we are using,e.g. a CRM, CMS, or ERP system can be a customized off-the-shelf system so there are many pieces to it.
Project work - This would be the other case and is where I'd probably try to build myself a view from 30,000 feet or so to know what are the high-level components and which areas of the system does the project impact. An example of this is where I'd join a company and work off of an existing code base but I don't have the luxury of having the small focus like in the previous case. Part of that view is to look for any patterns in the code in terms of naming conventions, project structure, etc. as this may be useful once I start changing some code in the system. I'd probably do some tracing through the system and try to see where are the uglier parts of the code. By uglier I mean those parts that are kludge-like and may have some spaghetti code as this was rushed when first written and is now being reworked heavily.
To my mind another way to view this is the question of whether I'm going to be spending days or weeks wrapping my head around a system like in the second case or should this be a case where it hopefully takes only a few hours, optimistically that is, to get my footing to make the necessary changes.