.Net Developer (TCP programming is a plus)

This job is no longer active!

View all jobs Qualysoft active

View all jobs .Net Developer (TCP programming is a plus) active on Hipo.ro

View all jobs IT Software active on Hipo.ro

Employer: Qualysoft
  • IT Software
  • Job type: full-time
    Job level: 1 - 5 years of experience
  • Updated at: 04.07.2019
    Short company description

    The Qualysoft Group was founded in Vienna in 1999. As an independent IT consultancy and service company, it supports its international customers by providing tailored IT solutions that are both flexible and innovative. Its main focus is on providers of financial and energy services, industrial firms, media/telecommunications companies, and institutions from the public sector.


    We are looking for a skilled programmer that with our help will develop this new system which consists of:
    - TCP listeners that can receive 2000+ messages / second / port and puts the messages in a queue along with metadata regarding the port and device that sent the message

    - The listener should send the correct ACK message back to the device for each message that is put in the queue (each device has a protocol that defines the structure of the messages sent and the format of the ACK message expected)

    - Message processors that take the messages from the queue(s) and based on the sending device protocol, break the messages into various entities that are persisted into the DB: points, events, alerts, etc.

    - This architecture must be resilient to errors and scalable so that if a device starts sending erroneous messages, the system does not crash

    Must have skills:

    - Must know the following programming languages: C#, SQL
    - Be comfortable with .NET Core, SQL Server, GIT
    - Network programming (TCP using sockets, client-server architecture)
    - Multi-threading and thread synchronization in C#

    Nice to have skills:

    - Alternatively, we were open to using Node.js for implementing the TCP listeners.


    - You will work closely with our development team and receive support for understanding the current implementation of the system and building, deploying and testing of the new system

    - We work using the SCRUM framework so you will be expected to participate in daily and weekly meetings with the team to discuss the progress and impediments that you encounter

    - To use the provided tools like JIRA / Confluence for ticket management and writing documentation

    - You will be expected to write clean and documented code and also write unit tests to assure that the code works correctly after changes

    - You must be self-organized and proactive by coming up with ideas of how to improve the system and not just expect to complete tasks assigned to you

    - The code will be submitted regularly to our GIT repository and code reviews will be performed to ensure a high standard of quality and eliminate possible bugs before testing

    Other info

    What we have now:

    Our current communication servers are windows services that bind and listen on specific TCP ports for device communication, via sockets.

    At this moment, each device message received is being processed, then the device receives back an ACK message from the server.
    The biggest problem is that the processing can take a long time and if the device does not receive the ACK in time, it re-sends the original message.

    This can cause delays in processing, exponentially increasing processing time by processing the same message multiple times and even block the service and potential loss of messages on restart.

    What we want to build:

    We want to rewrite these communication services using a scalable microservice approach.

    This means that we want to break each “service” into listeners that take the device messages and sends them in a persistent queue system (Rabbit MQ for example) and several consumers processes that take relevant messages from the queue and process them asynchronously.

    Each message can result in a list of: points, events, alerts, etc., after the processing is done.

    Not all of these need to be real time, points and events having priority.