I have a STEP 3D file and when I open through notepad, Its lot of entities and I gone through
http://www.steptools.com/support/stdev_docs/express/step_irs/html/schema.html#geometry_schema
but I could not understand the entities. Is there a documentation that explains these entities? If so it would be really helpful to understand.
The recommended practice for STEP AP 203 is a good place to start.
The CAX-IF recommended practices may also be useful, along with the schemas and file library.
If you need more information, the STEP Module and Resource Library can be purchased from ISO.
Related
I am building up a chart with 582 literal data points. When I call WordprocessingDocument.Close() I get an IsolatedStorageException.
This doesn't make sense to me because the OpenXML SDK, as I understand it, is totally self contained writing data to a stream. There's no calls to Office or anything else that could hit this issue.
Be that as it may, is there anything I can do to avoid this issue?
thanks - dave
I did some research into the IsolatedStorageException related to large XLSX files and found solutions to your problem.
According to Eric White's blog, when legacy OpenXml generates a file larger than 10M it needs to take advantage of Isolated Storage. If mulitple threads access the Isolated Storage during report generation System.IO.Packaging will throw the IsolatedStorageException.
This is because the System.IO.Packaging that is baked into .NET was not written well enough to handle these scenarios. That System.IO.Packaging can't be changed.
To remedy this issue, you can try one of these solutions:
Refactor your code to use a new OpenXml built on a System.IO.Packaging that Eric White refactored to remove the Isolated Storage depedency. Check this chart for reference and use the correct NuGet command to bring in the new version without the WindowsBase dependency.
Don't refactor your OpenXml code, but change your report generation user interface to prohibit (if possible) or discourage generating files larger than 10M.
If your OpenXml code is embedded inside an IIS based web solution and refactoring your code is not feasible, try one of the solutions provided by this blog. These techniques aim to provide permissions needed by IIS to try and get around this exception and might not be related to Eric White's concern.
Without more information about your solution architecture, these are the solutions I can recommend at this time. Hope they help.
scenario
We are evaluating breeze to adopt for our ionic mobile apps specifically for its offline caching capabilities. These apps will be consuming REST APIs powered by rails.
There currently exists functionality to generate json-schema from the ActiveRecord meta data through json_schema_builder and work is underway to dynamically expose a real-time schema definition. If anyone is keen to get involved please make your intentions known on the github issue since that is not the topic of this conversation.
breeze meta-data and json-schema
Overjoyed to find a page titled Meta Schema, impressed that breeze adopted json-schema to represent their meta-data. Equally disappointed to realize json-schema is only used to describe their own schema definition similar to the way meta schemas are used for describing json-schema itself.
json-schema 2 breeze meta-data
Lets not get into a debate on why we have json-schema defining yet another meta-data definition nor how valuable it would've been to have these efforts it took to accomplish this funneled into getting json-schema if it was found to be inadequate. Instead all I am searching to find is a way to turn existing json-schema into something breeze.js can understand. Google does not produce more on the topic, that I can find anyway, and the breeze project suggests we take it up here.
The documentation explains a way of loading meta-data from script by capturing the metadata from what I can only assume to be MC-CSDL Microsofts contribution to yet another standard defining the same.
Aside from doing it by hand and defeating the purpose of having these resources at our disposal, has anyone tried or know of ways to:
turn json-schema into breeze meta-data
perhaps any support for ActiveRecord reflections
at the very least something to query postgresql for the information
Feel free to correct me if you feel I am mistaken and I apologise in advance for any perceived audacities as it is not my intention to offend or annoy you. Please excuse me if I don't further entertain any complaints. I do however welcome any wisdom, insights and intellectual discourse on this topic and do very much appreciate your valuable time and input.
Thank you!
I appreciate your dilemma. I keep looking at json-schema in hopes that Breeze could join it as a standard. It just doesn't carry the information Breeze needs to manage data on the client.
The json-schema does carry much of the schema data that a Breeze client needs. While it might be inadequate on its own, it should give you a head start in writing Breeze metadata by hand.
Some glorious day I imagine a scenario such as this:
A JavaScript breeze-metadata-builder module that can combine metadata information feeds from multiple sources
A JSON configuration file that identifies those sources
One source is a json-schema feed
Another source returns hand-written "customizations" that fill-in-the-blanks from a Breeze metadata perspective
The breeze-metadata-builder merges the two sources into a single, Breeze metadata-format feed.
Run this process in node as a Grunt task, outputting a json or JavaScript file
Client on launch imports this metadata into a MetadataStore
Who is going to write it and share it with the community? How about you #nicki? I'll happily lend a hand.
I am writing my own custom persistence instance store for WF4, based on the XmlWorkflowInstanceStore found in the .NET 4 WF and WCF samples. This sample is quite simplistic and the xml is produces is quite verbose. I have issues with how some of the objects are serialized.
I have tried using Red Gate Reflector to understand the Sql implementation used, but it is quite complex and difficult to learn from. The MS documentation for this is rather limited - often giving one sentence descriptions for complex methods.
Please could you point me at other examples of WF4 persistence (or proper documentation) around on the web that are not copy and paste versions of XmlWorkflowInstanceStore? Maybe someone else on StackOverflow has written their own?
You are completely correct that the docs are very much lacking here and the sample is of very limited use. I have started work on a custom instance store using the entity framework but, much like you discovered, found it slow going and am nowhere near anything I could use myself, let alone release onto CodePlex.
I am not aware of any blog posts or other information that help solve this.
You've probably seen this already, but I've found the code quite easy to understand: http://xhinker.com/post/WF4Xml-persistence-store.aspx
Ron Jacobs wrote an in memory persistence store for WF unit testing. Check out http://wf.codeplex.com/releases/view/73842
I recently became part of a complex embedded project team for which I will be developing a part. For the part which is my responsibility there is only old code and not much documentation.
I am keen to make a good start but shyness and fear of appearing stupid makes it difficult to ask questions. How to ask questions ?
I wanted to ask what techniques do you guys use to understand a project ? I mean there are of lots of technical details which one must remember and keep in context in order to make a design. Your read the code and get some facts but how to move ahead ?
For instance you read the code and the document(s) and get some facts A and fact B . How to reach suitable conclusion X for which you may or may not have needed to take into account facts C and D also ?
Code-reading can be particularly difficult if there is not enough documentation and the code is poorly documented and badly written. I guess the best way now is to find the entry point of the code, and slowly understand its flows and what data it uses. I would keep a look out for
Structure - are there any partitioning of entities/system? Where in the code (and how) do they communicate with each other?
Data - what sort of structures are used to hold the global data? How are the data accessed and saved?
If you are doing C or C++, it is also important to find out how memory is handled and for C++ (and other related non-managed memory OOP languages, I guess), how are object ownership contained.
Since it is an embedded project, are there any non-standard code or coding constructs used?
Reading the code is balanced by writing the documentation.
Write the documentation that your replacement will need. Imagine someone who knows less than you. Explain it for that person.
When you cannot explain something to your replacement, ask questions.
When you have a complete description, you will "know" the system.
And you will have produced complete documentation.
You don't mention what kind of tests exist. If there are test cases, modify them and trace how this would affect the end result.
You might want to look at diagrams which give the entire picture of the logical structure of the system, like, for example, looking at class diagrams in an OOP system would be of great help. Looking at the design diagrams of large and complex apps gives you a clear understanding of how the internal modules of the system are organized and this way its makes the task of figuring out what functionality does a particular piece of code does much much easier. In the absence of diagrams, you're best bet would be to start from the entry point of the app, like main() and proceed from there while you draw(literally draw or write down on paper) your own conclusions about the system(this way you can have your own documentation) and ask your peers if they're correct.
My experience is that it's best to start with some kind of task -- a bug fix or other small change. That will provide focus to your learning. I find it hard to read through a binder or sift through pages of source code or documentation without having a way to apply it.
If you have a sandbox where you can play with changes that you've made without messing up the code base, that can be even more helpful.
At work I am responsible for writing specifications quite often and I am also the person who insisted on getting specifications in the first place. The problem is I am unsure how specifications should look and what they should contain. A lot of the time when my boss is writing the specifications (we are both inexperienced in it) they put in table names and things that I don't think belong there. So what is a good way to learn to write a good spec?
EDIT: Should a functional spec include things like assuming I am specifying a web application, the input types (a textbox, dropdown list, etc)?
The most important part of development documentation in my opinion, is having the correct person do it.
Requirements Docs - Users + Business Analyst
Functional Spec - Business Analyst + developer
Technical Spec (how the functionality will actually be implemented) - Sr. Developer /
Architect
Time estimates for scheduling purposes - The specific developer assigned to the task
Having anyone besides the Sr. Developer / Architect define table structures / interfaces etc. is an exercise in futility - as the more experienced developer will generally throw most of it out.
Wikipedia is actually a good start for the Functional Spec, which seems similar to your Spec - http://en.wikipedia.org/wiki/Functional_specification.
There's a great chapter in Steve McConnell's Code Complete that runs through specification documents and what they should contain.
When I was tasked to build an Architecture and Business Analysis team at a company that had never had either, I used McConnell's spec chapter to create the outline for the Technical Specification document. It evolved over time, but by starting out with this framework I made sure we didn't miss anything and it turned out to be surprisingly usable.
When writing specs, a rule of thumb I follow is to try to have technical documents always start from the general and move to the specific -- always restate the business problem(s) or goal(s) that the technical solution is being developed to solve, so the person reading the spec doesn't need to go to other documents to put it in any sort of context.
See Painless Functional Specs by Joel Spolsky.
Some of the things he says every spec should have:
A disclaimer
An author. One author
Scenarios
Nongoals
An Overview
Details, details, details
Open Issues
Side notes
The important thing is to get something written down rather than worry about the format.
Buy Books:
Requirements Engineering by Ian Sommerville & Pete Sawyer ISBN 0-471-97444-7
or
Software Requirements by Karl Wiegers ISBN 0-7356-0631-5