Design is as Dynamic as the Tool used
Click for a Visually Rich JD
Product Design begins as a hypothetical concept. Transforming that Concept into a functional Product is a highly creative and experimental process with nuanced understanding (expertise) of fundamentals & principles. Often, experiments give unknown outcomes and our concept changes as wildly as the output of the experiment. Coding is the centre piece in this immense amount of “experimental / Algorithm research”. When experiments change, code changes and the design team “distracted” by the burden of ‘bugs’ that come out of code modification and caught in the tool/language ‘Expertise’ needed to fix it. We need to be “enabled” to react and modify the code with least effort, so that the design team can focus on the evolution of concept by rapidly changing and performing the experiments without losing the thought chain – Minimize Context Switching for the Algo/Design team.
Except, we are a heavy HW product company and every code developed is highly HW oriented code. And what other programming language is better to do this than in LabVIEW? Our experiment is as flexible as the code allows us to be. As explorative as the scalability of the code is. And such code cannot be built without adhering to a thorough architecture, a completely dynamic and application agnostic design pattern with thorough Coding Practice and strong expertise of the tool – in this case LabVIEW.
You will be part of a 2 member LabVIEW development team, supported by the Founder on the architecture front and will work closely with the Design\Algo & C++ Development team. They are your internal customers.
Your primary contribution will be towards:
- Supporting CynLr’s ProductDesign and Algorithm Team in all LabVIEW Code development activities –Develop code and execute Experiments for algorithms, kinematics, and solutions that the design team comes up with.
- Translating the concepts that Design and algo teams comes up with into LabVIEW codes and experiments, adhering to the architecture and SW development life cycle.
- Performance coding and performance optimization of the code written – timing and memory.
- Build data visualizations to the needs of the Design and algo team
- Make more readily usable application UI for Lab Experiments to accelerate the Algo and design teams experiments.
- Code Refactoring: Owing to the rich experience in Architecting LabVIEW Development that the founders carry from their NI work experience, there is a strong Architecture, Design Pattern and coding guidelines put -in place. Understand the design pattern (STQ - CynLr's Own Design Pattern), Document, and translate the existing ‘spaghetti’ code bases and the new mock-up code of Design and Algo team to the coding standards with design pattern established by the founding team.
- Translate the development practices into the SW development lifecycle by proper Source Control, version control and Integration of the .dll Libraries developed by the C++ SW development team as the versions evolve, without breaking the existing code base.
- V&V: Coming up with test cases for the experiments and the code developed by the C++ Development team and interface the libraries and test for functionality and performance of the Algorithms developed. Executing the tests and validating the algorithms with HW-in-loop.
- Interface with the customer and support customerwith application implementation and delivery.
- Be the LabVIEW knowledge base and support system for the Algorithm/Design engineers and freshers who join the organization.
- Excellent understanding of Data Flow paradigm and understand parallel programming.
- Experienced with dynamic spawning of threads, services and thread management.
- Excellent understanding of “Re-entrancy” (this beckons basic understanding of Compiler working).
- Experienced with handling Race conditions, reference leaks, memory leaks and memory profiling.
- Excellent hands-on experience with debugging, Error Handling and profiling. (If you are experienced, its obvious that we never get the solution in the first short. We arrive at the solution by correcting the mistakes from our first attempt. If we are not equipped well with debugging, we cannot ‘know’ what to correct!!)
- Fundamentals of Testing, types of testing and Test Development. Testand Experience is a plus.
SW Design & Development:
- Must have excellent understanding and strong tendency to develop - Modular, Scalable and Maintainable code. We are ‘fixated’ with “Functional” output the code that we develop that, we forget about the “user” of the code – Code may work functionally but
- how easy is the code to integrate with other code?
- How easy is to test it?
- How easy is to develop further?
- How easy is to update or modify the code?
- How minimal a number of bugs happen or modifications I have to do to use this code with other code?
- Also, the Code often uses another code/library to build – e.g.: VISA, Vision Development Module, Mathscript module, etc. Unfortunately, contrary to our wish and belief that you have built bug-proof perfectly working code, the actual bugs will come out only when someone else uses them!! - This is SW Development lifecycle.
- Must have had experience with being a part ofSW Development lifecycle and Distributed Development – Source Control, Version Control, GIT and source distribution.
- Excellent with State Machine and must have at least been exposed to other design patterns and must have implemented at least a few times.
- Must have a strong understanding of OOPs and API architecture. Experience in developing an API library is a plus.
- Excellent with understanding the SW architecture and Design pattern established and building code adhering to them.
- Excellent proficiency with Graphing and Data Visualization and building custom Controls and UI elements. Xcontrols is a plus.
- Excellent with Subpanels, Resolution Reflow and Splitter management.
- Must have strong understanding of VI server (Methods and Attributes of LV Environment). VI scripting is a plus.
- Excellent with LabVIEW project settings, Environment settings – FP customization, function palette, dependency settings, all Debugging options, VI properties and LV productivity features.
- Adept with LVpointers/DVR, Queues and VI/ Application references.
- Experienced with making Project templates and distributing Project templates.
- Experienced with Quick drop app creation.
- Code cleanup: Clean, well document code development practice.
- Hands -on experience with Application builder :
- Compilation settings
- Folder settings for compiled output
- .exe creation
- Installer creation
- Lvlibp, LvLib, dll & llb creation
- Code distribution
Connectivity, Interface & HW Control:
- .dll library interface and C++ library/header interface. Experience with registry coding is a plus.
- Strong work experience with File handling – create, open, write, read & close sequences. Understanding of different file types & parsing data -
- config files -.ini, .json, etc;
- Data file formats: .xlsx, .csv, TDMS, etc;
- Images files - .png, bmp, etc ;
- Report generation and Report generation Toolkit.
- Strong work experience with implementing communication protocols – Ethernet (UDP, TCP), RS232/485, Industrial communication protocols like Modbus, CAN, etc.
- Good with Sensors, IO programming, PLC Automation, Cabling. Robot Ecosystem is a plus.
- Basic Programming skill with at least one Language - Python / C++.
Critical Thinking, Available, Responsible, Versatile, Resourceful, Thorough, Attention to Details & “Humble”.
CynLr is at its genesis as a start-up and as an organization. This role being the first to have been opened, it is the foundation of what would eventually be a for all the Code development fundamentals, Applications and Solutions for CynLr’s lab and customers.
The problem that we solve is multi-disciplinary, which interfaces with stakeholders from almost every Engineering Industry and every variety of strata in it. While this can be an immensely challenging scenario demanding constant learning and adaptation, if looked at it as an opportunity, it allows for a deep exposure to a rich variety of management and operational problems and opens door for plenty of alternate career options.
Needless to say, the exciting yet demanding part of a start-up - every passing day, the Company grows and the needs change, expansively.
In this context, beyond Specializing in the current Role as a LabVIEW Architect & LabVIEW development, which will grow as the organization expands, it also serves as a steppingstone into core technology design and development roles like C++ Code development, Gripper Design, Machine Learning Algorithm Design & Dev, Object Training and Task Model Specialist, Kinematics, Robot Design, Sensor Interface, Verification & Validation, etc. From the customer facing side, it can evolve as an alternative to tech into Robot Integration, Application Support, Solution engineering, Business Development, Vendor & Supply chain Management, Sales, etc.
If rightly used, this role presents you an opportunity to Build a unique Role of Your Own.