Martin Goldberg

As a part of my Ph.D. thesis, I built a prototype for how it would work was created. For this prototype, several aspects were dealt with.
Build:
1. A smart environment, i.e., a server that would anticipate connectivity via wireless communication and form an ad-hoc network.
2. The agent aspect of the system, i.e., the client system that would connect to the smart environment.
3. A language of communication.
4. Several other aspects of the smart environment and agent internet of things.
To facilitate the system, the server portion was built in C# in a console application that ran three main threads:
a) The main process. This process had an open port waiting for socket communication from a potential client. On receipt of the communication, this process would read the message and then act upon it. This included spawning new agent threads when a new client connected to the system.
b) A file watcher thread, whose purpose was to watch the FTP folder for incoming files.
c) The SE_Process thread (smart environment) which served as the backbone of the system. This process received messages designed for it from other threads and then acted upon them.
d) Agent threads were impermanent processes that communicated messages back to agents.

I built Raspberry Pi single-board computers, the agent or client system that connected to the server system or smart environment was written in Python 3.

Two main pieces were created for the prototype with the understanding that more could be added if required. Using the language developed for this purpose, one machine was designated the personal information hub (PiH) of the agent system.
The main function of this device was to control the conversation with the server and to pass on instruction to other parts of the IoT.

The second Raspberry Pi computer was set up to take photographs and send them to the server. Thus, a command would come from the PiH, the image would be taken, and then sent back to the server via FTP.

All communication was done through socket communication with ports being known to each device.

As a part of the work in the CUNY Visual Computing Lab, I worked on the Microsoft Kinect face tracking algorithm. My main contribution was building the WPF interface using C# and then reengineering the face-tracking algorithm to capture the points detected by the machine to generate a face mask and the rotation and translation to the 3D point set to create a forward-facing mask that could then be used for registration.

The basic project was taken up and developed into a gesture-recognition algorithm.

On this project, I've built several pieces in C# including the following:
1. The main processing system
2. A web-service interface for non-.NET applications to utilize

Using a WCF architecture, the system used an interface to accommodate the communication from outside. Class libraries were generated to give the system its shape and allow for data management. The back-end data access layer talked to a SQL Server database using T-SQL stored procedures.

In addition to the basic system, we added a ticketing system to generate tickets which allowed a second system to capture the tickets and display them as needed in other applications.

Given an incorrectly working application that was built to aid in processing survey data, we were then tasked with reverse-engineering the system, then correcting the problem, and finally to generate new screens.
The application was written in classic ASP 3.0. The back end was a SQL-Server database.

The program was built to provide similar data to unrecognized or ambiguous data entries. It considered partial strings for names and common nicknames, so Tom could be Tomas or Thomas, Jack could be John, and so forth.

I created this website for generating information among friends The site would load articles from an SQL Server database. These were displayed on a screen, the markup tags being part of the saved texts. The site could navigate between pages ensuring a limited visual on the page.

It was written in ASP.NET using C# with stored procedures in T-SQL from SQL Server databases.

To facilitate the input of the texts to the database, a WinForms application would read the text, allow for editing to match HTML tags, and upload it to the SQL Server databases. This was written in C#.

The site Tinskirox.com is no longer on the web.

I designed a search engine for a recruitment app; this included an advanced search. The app was built in ASP.NET and it was meant to aid recruiters in searching for potential employees based on various search criteria. It was based on a wireframe built by the architect and we also generated an interface.

Technologies: ASP.NET, HTML 4.0, JavaScript

A client was combining the memberships of two separate Windows Active Directory libraries. In the case of double entries, the system had to remove duplications. In order to manage this, we built an application in C# that also interacted with the Windows Active Directory through LDAP.

A precursor to cloud computing (2005), we created a company with a specific design in mind. It took into consideration that small companies, as well as small departments within a large company, might need to rapidly expand their data needs.

Ideally a B2B interface between interested companies could be generated. To facilitate this, we created a table generator using C# which would take in the parameters and generate SQL Server tables with keys and build stored procedures to allow for an ASP.NET interface to talk to the data.

A certain nonprofit with field offices in various countries needed a means for the field offices to store data.
Given a template of the required information, we built an application using MS-Access and VBA. The application allowed for cataloging and circulation management of the materials.

I was brought in to solve an issue. The coordinator would receive marketing program and product information. This was presented on an Excel spreadsheet of 125 lines on a single page. The data was collected over a period of 30 days, sent in for processing within the next 30 days, and then after a 30-day evaluation, it would be returned to the interested parties.

The data was transferred into an MS=Access database. After numerous meetings to ascertain what the data meant, normalization of the data happened. Once an interface that was built-in VBA was devised. the company requested the generation of reports in MS Excel.

Once all was set up, managers were asked to review the system. They came back and asked for the system to be created in a web interface. This was done in ASP 3.0 (2001). Once the managers were satisfied with the result, they could input potential marketing plans and get instant information on how this might affect the management of marketing.

In short, a 90-day process was made near-instantaneous.