TECH TUESDAYis a weekly content series covering all aspects of capital markets technology. TECH TUESDAY is produced in collaboration with Nasdaq.

Artificial intelligence (AI), specifically generative AI, has perhaps been the hottest emerging technology topic in markets of late. Traders Magazine caught up withMike ORourke, Head of AI and Emerging Technology at Nasdaq, to learn more about the current AI landscape and how it will evolve.

Tell us about your background and your current role at Nasdaq.

Ive been with Nasdaq for 25 years, the last 10 of which have been primarily focused on emerging technologiesAI, data science and our move to the cloud.

Back in 2016, I ran our data business technology; we were doing a lot of data science, but there was no formal data scienceprogramat Nasdaq. So, we built out a whole career track as well as a center of excellence for AI because, at the time, Brad Peterson, Chief Technology, and Information Officer at Nasdaq, and I anticipated that this was going to be very important. We wanted to start building up talent, a skill set and prowess in AI.

When did Nasdaq start using AI, and what were the early use cases?

The early projects at that time focused on using machine learning and AI language models to understand data and make new alternative data sets. How can we use AI to process unstructured data and convert it into structured data and knowledge so people can make better investments and trading decisions? We also used machine learning models to better understand trading activity and behavior. Why am I not getting the fill rate that I want? Why did this order not execute? How are my trading patterns compared to other firms? Things like that.

How has Nasdaqs cloud journey and partnership with Amazon Web Services (AWS) facilitated AI adoption?

AWS has been a wonderful partner. The cloud is really where innovations happen first, and Nasdaq took the stance that we needed to be early adopters by moving our data and systems there. It was about being agile and able to scale more easily.

Our investment in the cloud is paying offthe new emerging AI technologies are there, and because our data is there, too, we can readily implement these new models on top of our data. Weve invested a lot in having really good data systems, and to have good AI, you need sound data, which we have in the cloud.

AI is one of our strategic pillars across the companywe want to incorporate it into all our products and services, and the cloud is a significant enabler of this.

What current AI use cases are you most excited about?

Id be remiss if I didnt talk aboutDynamic Midpoint Extended Life Order (M-ELO), which is part of our dynamic markets program. We believe we can provide better service to our clients by having order types that can dynamically adapt to market conditions. Its still early days for Dynamic M-ELO, but its been quite successfulwere seeing increased order flow and higher hit rates, and were seeing no degradation in markouts. So, clients are clearly benefiting from the service.

Another part of dynamic markets is our strike optimization program, where we use machine learning models to figure out which strikes we should have listed in the options market. About 1.3 million strikes can be listed in the options market, so manually determining what strikes should be listed is difficult. We think this is a perfect use case where machines can do it better than humans.

We have several other items in the research phase, such as order types and other solutions within the dynamic markets program. We believe these two first launches are just the beginning of how AI will transform markets.

Generative AI has been a very hot topic. Do any AI use cases at Nasdaq utilize generative AI?

Broadly speaking, if theres an investigative component anywhere within a solution set, generative AI can be very valuable.

As for specific applications, ourVerafinand market surveillance solutions are rolling out automated investigators that use generative AI to make investigating illicit activities more effortless. We recently launched a feature inBoardVantagethat allows us to summarize documents, which can make reviewing length board documents easier.

Beyond those examples, there are a host of new product enhancements that use generative AI. Really, anywhere theres a user interface where people are trying to answer questions, youre probably going to see some sort of generative chatbot interface in the near future.

What will the AI adoption weve been talking about mean for Nasdaq and the markets in the future?

Information can be acted upon much more quickly because generative systems can summarize data more quickly.

Im dating myself here, but when I was a kid, if I wanted to research something, I had to go to the libraryit would take me quite a long time to find the answer. With the advent of the internet, I didnt have to drive to the library anymore. And then when mobile came out, I didnt even have to go home to my computer. Timeframes for information access have gotten shorter and shorterand generative AI will further compress that time.

The upshot for markets is that information will be acted upon much more quickly. This is why we think dynamic market solutions are so important.

What about generative AI raises caution flags?

Generative AI is an incredibly exciting area, but there are risks, and people need to take those risks seriously.

How are AI models built, how are they trained and where are they hosted? At Nasdaq, we focus on having excellent AI governance, where anything that goes out is looked at from a compliance, regulatory and technology perspective to ensure its safe, secure and scalable for clients. No AI solution goes out without a rigorous governance process to ensure that the models are effective and can be trusted.

Explainability is also critical. When we came to market with some of our dynamic market solutions, like Dynamic M-ELO, we were very transparent; in fact, we published a whole whitepaper about it. We covered questions like what features are going into the model, how the model behaves and what type of information it will use to make decisions.

Having that transparency and explainability is essential, and its something we value at Nasdaq.

Transparency is a core value for Nasdaq and a key part of what makes modern financial markets work so well. When it comes to generative AI at Nasdaq, transparency is equally important. Being able to explain both where information comes from and why its relevant is critical to ensuring generative AI is trustworthy and effective. Were excited about what transformation opportunities generative AI can provide, and we look forward to continuing this journey of discovery.

Creating tomorrows markets today. Find out more about Nasdaqs offerings to drive your business forwardhere.

Excerpt from:

TECH TUESDAY: Assessing the Present and Future of AI in Markets - Traders Magazine

12 min read

In this tutorial, I want to show you how to downsample a stream of sensor data using only Python (and Redpanda as a message broker). The goal is to show you how simple stream processing can be, and that you dont need a heavy-duty stream processing framework to get started.

Until recently, stream processing was a complex task that usually required some Java expertise. But gradually, the Python stream processing ecosystem has matured and there are a few more options available to Python developers such as Faust, Bytewax and Quix. Later, Ill provide a bit more background on why these libraries have emerged to compete with the existing Java-centric options.

But first lets get to the task at hand. We will use a Python libary called Quix Streams as our stream processor. Quix Streams is very similar to Faust, but it has been optimized to be more concise in its syntax and uses a Pandas like API called StreamingDataframes.

You can install the Quix Streams library with the following command:

What youll build

Youll build a simple application that will calculate the rolling aggregations of temperature readings coming from various sensors. The temperature readings will come in at a relatively high frequency and this application will aggregate the readings and output them at a lower time resolution (every 10 seconds). You can think of this as a form of compression since we dont want to work on data at an unnecessarily high resolution.

You can access the complete code in this GitHub repository.

This application includes code that generates synthetic sensor data, but in a real-world scenario this data could come from many kinds of sensors, such as sensors installed in a fleet of vehicles or a warehouse full of machines.

Heres an illustration of the basic architecture:

The previous diagram reflects the main components of a stream processing pipeline: You have the sensors which are the data producers, Redpanda as the streaming data platform, and Quix as the stream processor.

Data producers

These are bits of code that are attached to systems that generate data such as firmware on ECUs (Engine Control Units), monitoring modules for cloud platforms, or web servers that log user activity. They take that raw data and send it to the streaming data platform in a format that that platform can understand.

Streaming data platform

This is where you put your streaming data. It plays more or less the same role as a database does for static data. But instead of tables, you use topics. Otherwise, it has similar features to a static database. Youll want to manage who can consume and produce data, what schemas the data should adhere to. Unlike a database though, the data is constantly in flux, so its not designed to be queried. Youd usually use a stream processor to transform the data and put it somewhere else for data scientists to explore or sink the raw data into a queryable system optimized for streaming data such as RisingWave or Apache Pinot. However, for automated systems that are triggered by patterns in streaming data (such as recommendation engines), this isnt an ideal solution. In this case, you definitely want to use a dedicated stream processor.

Stream processors

These are engines that perform continuous operations on the data as it arrives. They could be compared to just regular old microservices that process data in any application back end, but theres one big difference. For microservices, data arrives in drips like droplets of rain, and each drip is processed discreetly. Even if it rains heavily, its not too hard for the service to keep up with the drops without overflowing (think of a filtration system that filters out impurities in the water).

For a stream processor, the data arrives as a continuous, wide gush of water. A filtration system would be quickly overwhelmed unless you change the design. I.e. break the stream up and route smaller streams to a battery of filtration systems. Thats kind of how stream processors work. Theyre designed to be horizontally scaled and work in parallel as a battery. And they never stop, they process the data continuously, outputting the filtered data to the streaming data platform, which acts as a kind of reservoir for streaming data. To make things more complicated, stream processors often need to keep track of data that was received previously, such as in the windowing example youll try out here.

Note that there are also data consumers and data sinks systems that consume the processed data (such as front end applications and mobile apps) or store it for offline analysis (data warehouses like Snowflake or AWS Redshift). Since we wont be covering those in this tutorial, Ill skip over them for now.

In this tutorial, Ill show you how to use a local installation of Redpanda for managing your streaming data. Ive chosen Redpanda because its very easy to run locally.

Youll use Docker compose to quickly spin up a cluster, including the Redpanda console, so make sure you have Docker installed first.

First, youll create separate files to produce and process your streaming data. This makes it easier to manage the running processes independently. I.e. you can stop the producer without stopping the stream processor too. Heres an overview of the two files that youll create:

As you can see the stream processor does most of the heavy lifting and is the core of this tutorial. The stream producer is a stand-in for a proper data ingestion process. For example, in a production scenario, you might use something like this MQTT connector to get data from your sensors and produce it to a topic.

Youll start by creating a new file called sensor_stream_producer.py and define the main Quix application. (This example has been developed on Python 3.10, but different versions of Python 3 should work as well, as long as you are able to run pip install quixstreams.)

Create the file sensor_stream_producer.py and add all the required dependencies (including Quix Streams)

Then, define a Quix application and destination topic to send the data.

The value_serializer parameter defines the format of the expected source data (to be serialized into bytes). In this case, youll be sending JSON.

Lets use the dataclass module to define a very basic schema for the temperature data and add a function to serialize it to JSON.

Next, add the code that will be responsible for sending the mock temperature sensor data into our Redpanda source topic.

This generates 1000 records separated by random time intervals between 0 and 1 second. It also randomly selects a sensor name from a list of 5 options.

Now, try out the producer by running the following in the command line

You should see data being logged to the console like this:

Once youve confirmed that it works, stop the process for now (youll run it alongside the stream processing process later).

The stream processor performs three main tasks: 1) consume the raw temperature readings from the source topic, 2) continuously aggregate the data, and 3) produce the aggregated results to a sink topic.

Lets add the code for each of these tasks. In your IDE, create a new file called sensor_stream_processor.py.

First, add the dependencies as before:

Lets also set some variables that our stream processing application needs:

Well go into more detail on what the window variables mean a bit later, but for now, lets crack on with defining the main Quix application.

Note that there are a few more application variables this time around, namely consumer_group and auto_offset_reset. To learn more about the interplay between these settings, check out the article Understanding Kafkas auto offset reset configuration: Use cases and pitfalls

Next, define the input and output topics on either side of the core stream processing function and add a function to put the incoming data into a DataFrame.

Weve also added a logging line to make sure the incoming data is intact.

Next, lets add a custom timestamp extractor to use the timestamp from the message payload instead of Kafka timestamp. For your aggregations, this basically means that you want to use the time that the reading was generated rather than the time that it was received by Redpanda. Or in even simpler terms Use the sensors definition of time rather than Redpandas.

Why are we doing this? Well, we could get into a philosophical rabbit hole about which kind of time to use for processing, but thats a subject for another article. With the custom timestamp, I just wanted to illustrate that there are many ways to interpret time in stream processing, and you dont necessarily have to use the time of data arrival.

Next, initialize the state for the aggregation when a new window starts. It will prime the aggregation when the first record arrives in the window.

This sets the initial values for the window. In the case of min, max, and mean, they are all identical because youre just taking the first sensor reading as the starting point.

Now, lets add the aggregation logic in the form of a reducer function.

This function is only necessary when youre performing multiple aggregations on a window. In our case, were creating count, min, max, and mean values for each window, so we need to define these in advance.

Next up, the juicy part adding the tumbling window functionality:

This defines the Streaming DataFrame as a set of aggregations based on a tumbling window a set of aggregations performed on 10-second non-overlapping segments of time.

Tip: If you need a refresher on the different types of windowed calculations, check out this article: A guide to windowing in stream processing.

Finally, produce the results to the downstream output topic:

Note: You might wonder why the producer code looks very different to the producer code used to send the synthetic temperature data (the part that uses with app.get_producer() as producer()). This is because Quix uses a different producer function for transformation tasks (i.e. a task that sits between input and output topics).

As you might notice when following along, we iteratively change the Streaming DataFrame (the sdf variable) until it is the final form that we want to send downstream. Thus, the sdf.to_topic function simply streams the final state of the Streaming DataFrame back to the output topic, row-by-row.

The producer function on the other hand, is used to ingest data from an external source such as a CSV file, an MQTT broker, or in our case, a generator function.

Finally, you get to run our streaming applications and see if all the moving parts work in harmony.

First, in a terminal window, start the producer again:

Then, in a second terminal window, start the stream processor:

Pay attention to the log output in each window, to make sure everything is running smoothly.

You can also check the Redpanda console to make sure that the aggregated data is being streamed to the sink topic correctly (youll fine the topic browser at: http://localhost:8080/topics).

What youve tried out here is just one way to do stream processing. Naturally, there are heavy duty tools such Apache Flink and Apache Spark Streaming which are have also been covered extensively online. But those are predominantly Java-based tools. Sure, you can use their Python wrappers, but when things go wrong, youll still be debugging Java errors rather than Python errors. And Java skills arent exactly ubiquitous among data folks who are increasingly working alongside software engineers to tune stream processing algorithms.

In this tutorial, we ran a simple aggregation as our stream processing algorithm, but in reality, these algorithms often employ machine learning models to transform that data and the software ecosystem for machine learning is heavily dominated by Python.

An oft overlooked fact is that Python is the lingua franca for data specialists, ML engineers, and software engineers to work together. Its even better than SQL because you can use it to do non-data-related things like make API calls and trigger webhooks. Thats one of the reasons why libraries like Faust, Bytewax and Quix evolved to bridge the so-called impedance gap between these different disciplines.

Hopefully, Ive managed to show you that Python is a viable language for stream processing, and that the Python ecosystem for stream processing is maturing at a steady rate and can hold its own against the older Java-based ecosystem.

See the original post here:

Aggregating Real-time Sensor Data with Python and Redpanda - Towards Data Science

We will spend some time to go over the environment preparation. Afterwards, this article is divided into 3 sections:

We are now ready to start!

They are the building blocks of prompt programming in DSPy. Lets dive in to see what they are about!

A signature is the most fundamental building block in DSPys prompt programming, which is a declarative specification of input/output behavior of a DSPy module. Signatures allow you to tell the LM what it needs to do, rather than specify how we should ask the LM to do it.

Say we want to obtain the sentiment of a sentence, traditionally we might write such prompt:

But in DSPy, we can achieve the same by defining a signature as below. At its most basic form, a signature is as simple as a single string separating the inputs and output with a ->

Note: Code in this section contains those referred from DSPys documentation of Signatures

The prediction is not a good one, but for instructional purpose lets inspect what was the issued prompt.

We can see the above prompt is assembled from the sentence -> sentiment signature. But how did DSPy came up with the Given the fields in the prompt?

Inspecting the dspy.Predict() class, we see when we pass to it our signature, the signature will be parsed as the signature attribute of the class, and subsequently assembled as a prompt. The instructions is a default one hardcoded in the DSPy library.

What if we want to provide a more detailed description of our objective to the LLM, beyond the basic sentence -> sentiment signature? To do so we need to provide a more verbose signature in form of Class-based DSPy Signatures.

Notice we provide no explicit instruction as to how the LLM should obtain the sentiment. We are just describing the task at hand, and also the expected output.

It is now outputting a much better prediction! Again we see the descriptions we made when defining the class-based DSPy signatures are assembled into a prompt.

This might do for simple tasks, but advanced applications might require sophisticated prompting techniques like Chain of Thought or ReAct. In DSPy these are implemented as Modules

We may be used to apply prompting techniques by hardcoding phrases like lets think step by step in our prompt . In DSPy these prompting techniques are abstracted as Modules. Lets see below for an example of applying our class-based signature to the dspy.ChainOfThought module

Notice how the Reasoning: Lets think step by step phrase is added to our prompt, and the quality of our prediction is even better now.

According to DSPys documentation, as of time of writing DSPy provides the following prompting techniques in form of Modules. Notice the dspy.Predict we used in the initial example is also a Module, representing no prompting technique!

It also have some function-style modules:

6. dspy.majority: Can do basic voting to return the most popular response from a set of predictions.

You can check out further examples in each modules respective guide.

On the other hand, what about RAG? We can chain the modules together to deal with bigger problems!

First we define a retriever, for our example we use a ColBERT retriever getting information from Wikipedia Abstracts 2017

Then we define the RAG class inherited from dspy.Module. It needs two methods:

Note: Code in this section is borrowed from DSPys introduction notebook

Then we make use of the class to perform a RAG

Inspecting the prompt, we see that 3 passages retrieved from Wikipedia Abstracts 2017 is interpersed as context for Chain of Thought generation

The above examples might not seem much. At its most basic application the DSPy seemed only doing nothing that cant be done with f-string, but it actually present a paradigm shift for prompt writing, as this brings modularity to prompt composition!

First we describe our objective with Signature, then we apply different prompting techniques with Modules. To test different prompt techniques for a given problem, we can simply switch the modules used and compare their results, rather than hardcoding the lets think step by step (for Chain of Thought) or you will interleave Thought, Action, and Observation steps (for ReAct) phrases. The benefit of modularity will be demonstrated later in this article with a full-fledged example.

The power of DSPy is not only limited to modularity, it can also optimize our prompt based on training samples, and test it systematically. We will be exploring this in the next section!

In this section we try to optimize our prompt for a RAG application with DSPy.

Taking Chain of Thought as an example, beyond just adding the lets think step by step phrase, we can boost its performance with a few tweaks:

Doing this manually would be highly time-consuming and cant generalize to different problems, but with DSPy this can be done automatically. Lets dive in!

#1: Loading test data: Like machine learning, to train our prompt we need to prepare our training and test datasets. Initially this cell will take around 20 minutes to run.

Inspecting our dataset, which is basically a set of question-and-answer pairs

#2 Set up Phoenix for observability: To facilitate understanding of the optimization process, we launch Phoenix to observe our DSPy application, which is a great tool for LLM observability in general! I will skip pasting the code here, but you can execute it in the notebook.

Note: If you are on Windows, please also install Windows C++ Build Tools here, which is necessary for Phoenix

Then we are ready to see what this opimitzation is about! To train our prompt, we need 3 things:

Now we train our prompt.

Before using the compiled_rag to answer a question, lets see what went behind the scene during the training process (aka compile). We launch the Phoenix console by visiting http://localhost:6006/ in browser

In my run I have made 14 calls using the RAG class, in each of those calls we post a question to LM to obtain a prediction.

Refer to the result summary table in my notebook, 4 correct answers are made from these 14 samples, thus reaching our max_bootstrapped_demos parameter and stopping the calls.

But what are the prompts DSPy issued to obtain the bootstrapped demos? Heres the prompt for question #14. We can see as DSPy tries to generate one bootstrapped demo, it would randomly add samples from our trainset for few-short learning.

Time to put the compiled_rag to test! Here we raise a question which was answered wrongly in our summary table, and see if we can get the right answer this time.

We now get the right answer!

Again lets inspect the prompt issued. Notice how the compiled prompt is different from the ones that were used during bootstrapping. Apart from the few-shot examples, bootstrapped Context-Question-Reasoning-Answer demonstrations from correct predictions are added to the prompt, improving the LMs capability.

So the below is basically went behind the scene with BootstrapFewShot during compilation:

The above example still falls short of what we typically do with machine learning: Even boostrapping maybe useful, we are not yet proving it to improve the quality of the responses.

Ideally, like in traditional machine learning we should define a couple of candidate models, see how they perform against the test set, and select the one achieving the highest performance score. This is what we will do next!

In this section, we want to evaluate what is the best prompt (expressed in terms of module and optimizer combination) to perform a RAG against the HotpotQA dataset (distributed under a CC BY-SA 4.0 License), given the LM we use (GPT 3.5 Turbo).

The Modules under evaluation are:

And the Optimizer candidates are:

As for evaluation metric, we again use exact match as criteria (dspy.evaluate.metrics.answer_exact_match) against the test set.

Lets begin! First, we define our modules

Then define permutations for our model candidates

Then I defined a helper class to facilitate the evaluation. The code is a tad bit long so I am not pasting it here, but it could be found in my notebook. What it does is to apply each the optimizers against the modules, compile the prompt, then perform evaluation against the test set.

We are now ready to start the evaluation, it would take around 20 minutes to complete

Heres the evaluation result. We can see the COT module with BootstrapFewShot optimizer has the best performance. The scores represent the percentage of correct answers (judged by exact match) made for the test set.

But before we conclude the exercise, it might be useful to inspect the result more deeply: Multihop with BootstrapFewShot, which supposedly equips with more relevant context than COT with BootstrapFewShot, has a worse performance. It is strange!

Now head to the Phoenix Console to see whats going on. We pick a random question William Hughes Miller was born in a city with how many inhabitants ?, and inspect how did COT, ReAct, BasicMultiHop with BoostrapFewShot optimizer came up with their answer. You can type this in the search bar for filter: """William Hughes Miller was born in a city with how many inhabitants ?""" in input.value

These are the answers provided by the 3 models during my run:

The correct answer is 7,402 at the 2010 census. Both ReAct with BootstrapFewShot and COT with BootstrapFewShot provided relevant answers, but Multihop with BootstrapFewShot simply failed to provide one.

Checking the execution trace in Phoenix for Multihop with BootstrapFewShot, looks like the LM fails to understand what is expected for the search_query specified in the signature.

So we revise the signature, and re-run the evaluation with the code below

We now see the score improved across all models, and Multihop with LabeledFewShot and Multihop with no examples now have the best performance! This indicates despite DSPy tries to optimize the prompt, there is still some prompt engineering involved by articulating your objective in signature.

The best model now produce an exact match for our question!

Since the best prompt is Multihop with LabeledFewShot, the prompt does not contain bootstrapped Context-Question-Reasoning-Answer demonstrations. So bootstrapping may not surely lead to better performance, we need to prove which one is the best prompt scientifically.

It does not mean Multihop with BootstrapFewShot has a worse performance in general however. Only that for our task, if we use GPT 3.5 Turbo to bootstrap demonstration (which might be of questionable quality) and output prediction, then we might better do without the bootstrapping, and keep only the few-shot examples.

This lead to the question: Is it possible to use a more powerful LM, say GPT 4 Turbo (aka teacher) to generate demonstrations, while keeping cheaper models like GPT 3.5 Turbo (aka student) for prediction?

The answer is YES as the following cell demonstrates, we will use GPT 4 Turbo as teacher.

Using GPT-4 Turbo as teacher does not significantly boost our models performance however. Still it is worthwhile to see its effect to our prompt. Below is the prompt generated just using GPT 3.5

And heres the prompt generated using GPT-4 Turbo as teacher. Notice how the Reasoning is much better articulated here!

Currently we often rely on manual prompt engineering at best abstracted as f-string. Also, for LM comparison we often raise underspecified questions like how do different LMs compare on a certain problem, borrowed from the Stanford NLP papers saying.

But as the above examples demonstrate, with DSPys modular, composable programs and optimizers, we are now equipped to answer toward how they compare on a certain problem with Module X when compiled with Optimizer Y, which is a well-defined and reproducible run, thus reducing the role of artful prompt construction in modern AI.

Thats it! Hope you enjoy this article.

*Unless otherwise noted, all images are by the author

Read this article:

Prompt Like a Data Scientist: Auto Prompt Optimization and Testing with DSPy - Towards Data Science

Algorithms that process complex financial data. Sensors that track and monitor endangered species. Systems that track patient health records across hospitals and the cybersecurity tools to keep them secure. Computing and data now touch nearly every facet of daily life and the worlds industries, a trend that only continues to grow.

With these rapid technological advancements, the University of New England has announced the formation of a School of Computer Science and Data Analytics offering a diverse range of programs aimed at equipping students with the essential knowledge and skills needed to thrive in today's rapidly advancing technological landscape.

Embedded within UNEs College of Arts and Sciences, the new school reflects UNEs commitment to meeting the rising demand for professionals with skills in emerging technologies,such as artificial intelligence, cybersecurity, and data analytics. UNE has hired Sylvain Jaume, Ph.D., a leading artificial intelligence expert and founder of one of the nations first data science degree programs, as the schools inaugural director.

The school will comprise UNEs existing majors in Applied Mathematics and Data Science, plus two new majors in Computer Science and Statistics, designed to ensure that the regional and national workforce is well-equipped to navigate and contribute to ongoing advancements in each industry.

As we embark on this new venture, we are mindful of the critical role our graduates will play in shaping the future, and specializations in computer science and data science are increasingly sought after in today's job market, remarked Gwendolyn Mahon, UNEs provost and senior vice president of Academic Affairs. The launch of this school aligns with UNEs mission to empower our graduates with the expertise required to drive innovation and address the worlds complex challenges.

According to the U.S. Bureau of Labor Statistics, employment of computer scientists isprojected to grow 23% through 2032, which is much faster than the average for all occupations (3%). A recent study by labor analytics firm Lightcast reported a total of 807,000 positions seeking qualified computer science graduates were posted in 2022 alone.

The Computer Science major at UNE will build on the institutions leading reputation in interdisciplinary learning, fostering connections across the Universitys diverse academic and professional disciplines including the health sciences, biology, marine science, and business and setting students up for varied academic and research opportunities.

New courses in computer architecture, software engineering, and computational theory will prepare students for necessary jobs across a spectrum of fields including health care, financial services, biotechnology, and cybersecurity. Students will additionally gain hands-on experience through internships, providing them with real-world insights into these growing fields as well as valuable networking opportunities.

Enrollment for the new majors will begin in fall 2025.

This transition reflects the agile nature of UNE to rethink how we educate our students to break new ground in Maine and our nations most sought-after industries, remarked Jonathan Millen, Ph.D., dean of the College of Arts and Sciences. These new programs exemplify UNE's dedication to innovation, excellence, and preparing future leaders to tackle the challenges of tomorrow.

See original here:

UNE announces new School of Computer Science and Data Analytics - University of New England

New York, NY - O'Dwyer's, a leading public relations industry publication, has announced its annual PR rankings, naming 5WPRs Technology PR Division the 13thlargest in the US. With net fees over $15 million, the agencys technology practice remains in the top 15 rankings for over 5 years running.

For the last 55 years, O'Dwyer's has been ranking PR agencies based on their fees and has verified by reviewing PR firm income statements.

5Ws technology client partners span the globe and every sector of the space, from adtech and fintech, to artificial intelligence and cybersecurity said Matt Caiola, Co-CEO, 5WPR. It is a fast-changing industry that requires a high level of skill to navigate. The dedication of our team makes all the difference and ensures results-driven work that makes a noticeable difference in our clients brand identity.

Notable clients of the practice include home automation company Samsung SmartThings, legal AI company Casetext, multinational payment and transactional services platform Worldline, data-driven marketing solution Zeta Global, leader in AI-driven narrative and risk intelligence Blackbird.AI, trading software Webull, and the number one enterprise experience platform for critical insights and action, Medallia.

In addition to this recognition, 5WPR has also been named a top-twoNew York City PR agency, and a top US agency by ODwyers this year.

See original here:

5WPR Technology PR Division Named Among Top in the US - CIOReview