Dans cet article, je partagerai le thème que nous avons présenté lors du Global Summit 2023, dans la salle Tech Exchange. Moi et @Rochael Ribeiro
Lors de cette présentation, nous abordons les sujets suivants :
Bonjour la communauté !
Nous avons publié une nouvelle version d'IrisApiTester. Il intègre plusieurs nouveautés telles que :
Dans mon dernier article, j'ai parlé du renvoi de valeurs avec Python. Mais les renvoyer est simple, ce qui peut rendre les choses plus difficiles, c'est ce dont je vais parler aujourd'hui : où la valeur est traitée.
En suivant l'exemple du dernier article, nous avons la méthode : objet dans IRIS
Class python.returnTest [ Abstract ]
{
ClassMethod returnSomething(pValue... As%String) As%Integer [ Language = python ]
{
return pValue
}
}Lorsqu'il s'agit de créer une image d'IRIS, nous pouvons utiliser les fichiers merge.cpf.
Voici un exemple de merge.cpf :
[Actions]
CreateDatabase:Name=IRISAPP_DATA,Directory=/usr/irissys/mgr/IRISAPP_DATA
CreateDatabase:Name=IRISAPP_CODE,Directory=/usr/irissys/mgr/IRISAPP_CODE
CreateNamespace:Name=IRISAPP,Globals=IRISAPP_DATA,Routines=IRISAPP_CODE,Interop=1
ModifyService:Name=%Service_CallIn,Enabled=1,AutheEnabled=48
CreateApplication:Name=/frn,NameSpace=IRISAPP,DispatchClass=Formation.REST.Dispatch,AutheEnabled=48
ModifyUser:Name=SuperUser,PasswordHash=a31d24aecc0bfe560a7e45bd913ad27c667dc25a75cbfd358c451bb595b6bd52bd25c82cafaa23ca1dd30b3b4947d12d3bb0ffb2a717df29912b743a281f97c1,0a4c463a2fa1e7542b61aa48800091ab688eb0a14bebf536638f411f5454c9343b9aa6402b4694f0a89b624407a5f43f0a38fc35216bb18aab7dc41ef9f056b1,10000,SHA512
Le fichier merge.cpf est un fichier texte contenant par exemple un ensemble d'actions. Ici, nous créons deux bases de données, un espace de noms, nous activons le service CallIn, créons une application Web et nous modifions un utilisateur.
Le fichier **merge.cpf **peut être exécuté lorsque IRIS démarre en utilisant cette variable d'environnement :
ISC_CPF_MERGE_FILE=/tmp/iris.cpf
Il peut être utile d'utiliser cette variable d'environnement pour créer une image IRIS. Voici un exemple de Dockerfile :
ARG IMAGE=intersystemsdc/iris-community:latest
FROM $IMAGE as builder
WORKDIR /irisdev/app
RUN chown ${ISC_PACKAGE_MGRUSER}:${ISC_PACKAGE_IRISGROUP} /irisdev/app
USER ${ISC_PACKAGE_MGRUSER}
COPY . /irisdev/app
ENV ISC_CPF_MERGE_FILE=/irisdev/app/merge.cpf
RUN iris start IRIS \
&& iris session IRIS < /irisdev/app/iris.script \
&& iris stop IRIS quietly
Pendant la construction, lorsque cette commande iris start est exécutée, le fichier merge.cpf est exécuté.
J'espère que cela vous sera utile.
Dans cet article, nous allons voir comment utiliser le service de messagerie instantanée WhatsApp depuis InterSystems IRIS pour envoyer des messages à différents destinataires. Pour ce faire, nous devons créer et configurer un compte dans Meta et configurer une opération métier pour envoyer les messages que nous souhaitons.
Examinons chacune de ces étapes plus en détail.
C'est peut-être le point le plus compliqué de toute la configuration, puisque nous devrons configurer une série de comptes jusqu'à ce que nous puissions avoir la fonctionnalité de messagerie.
Sous Linux, suivez les étapes suivantes pour supprimer une instance d'InterSystems IRIS (ci-après dénommée IRIS).
(1) Arrêtez l'instance IRIS que vous souhaitez désinstaller à l'aide de iris stop
# iris stop <instance name>(2)Supprimez les informations de l'instance à l'aide de la commande suivante
# iris delete <instance name>(3) Supprimez le répertoire d'installation d'IRIS à l'aide de la commande rm -r
# rm -r <install directory>En plus du répertoire d'installation, IRIS utilise également (a) et (b) ci-dessous.
Django, un framework Web de haut niveau écrit en Python, est devenu un incontournable pour les développeurs à la recherche d'une solution robuste, efficace et facile à apprendre pour créer des applications Web. Sa popularité vient de sa polyvalence, offrant aux développeurs une boîte à outils efficace pour créer des applications Web. L'intégration de Django avec InterSystems IRIS introduit une synergie dynamique, offrant aux développeurs une solution complète de développement Web et de gestion de bases de données. C'est pourquoi sur le Portail des Idées, @Evgeny Shvarov a suggéré qu'avoir des Exemples pour travailler avec IRIS et Django serait bénéfique. Dans cet article, nous explorerons deux projets créés pour répondre à l'idée publiée —Django-iris par @Dmitry Maslennikov et Iris-size-django par @Heloisa.Paiva.
La nouveauté de la version 2023.3 (d'InterSystems IRIS for Health) est une fonctionnalité permettant d'effectuer une validation basée sur le profil FHIR.
(*)
Dans cet article, je vais fournir un aperçu de base de cette fonctionnalité.
Si FHIR est important pour vous, vous devriez absolument essayer cette nouvelle fonctionnalité, alors poursuivez votre lecture.
InterSystems Kubernetes Operator (IKO) 3.7 est désormais généralement disponible. IKO 3.7 ajoute de nouvelles fonctionnalités importantes ainsi que de nombreuses corrections de bugs. Les points forts incluent :
Bonjour La Communauté,
Le langage SQL reste le moyen le plus pratique pour récupérer de l'information stockée en base de données.
Le format JSON est très souvent utilisé dans les échanges de données.
Il est donc fréquent de chercher à obtenir des données au format JSON à partir de requêtes SQL.
Vous trouverez ci-dessous des exemples simples qui pourront vous aider à répondre à ce besoin à partir de code en ObjectScript et en Python.
ObjectScript : via le SQL dynamique avec %SQL.Statement + les structures JSON avec %DynamicObject et %DynamicArray
Health Data De-Identifier est disponible via InterSystems' Early Access Program afin de vous donner un aperçu de ce sur quoi nous travaillons. Ce document vous expliquera comment vous inscrire.
Pour en savoir plus: Health Data De-ID Early Access Program
Accéder evaluation.intersystems.com. Si vous disposez déjà d'informations d'identification, passez à l'étape 7.
Créer un nouveau compte en cliquant sur Register for a new account.
Remplissez toutes les informations requises et enregistrez.
Vous recevrez un email avec la confirmation et le token d'accès.
Fournissez le token d'accès reçu par e-mail.
Choisissez un mot de passe.
Envoyer un courriel à deidevaluation@intersystems.com demander l'accès (cliquez sur le lien pour un accès rapide). Il est important de demander l'accès pour le même e-mail que vous avez utilisé lors du processus d'inscription.
Une fois que vous avez reçu la confirmation de votre inscription, connectez-vous à evaluation.intersystems.com et cliquez sur Télécharger les programmes d'accès anticipé.
Sélectionner Health Data De-Identifier. Assurez-vous de lire et d'accepter les Conditions d'utilisation de l'accès anticipé puis cliquez sur Download All.
Dans ce deuxième article sur les principes fondamentaux des conteneurs, nous examinons ce que sont les images de conteneurs.
Une image Docker est simplement une représentation binaire d'un conteneur.
Un conteneur en cours d'exécution ou simplement un conteneur est l'état d'exécution de l'image du conteneur associée.
Pour plus d'information, n'hésitez pas à lire l'article qui explique ce qu'est un conteneur.
Nous sommes de retour à %SYS ! Puisque nous avons abordé la gestion des utilisateurs et des ressources dans les deux derniers articles, nous pouvons enfin passer aux rôles. Comme vous l’avez peut-être deviné, il existe de nombreuses méthodes pour les gérer que vous avez déjà vues dans nos écrits précédents. Cependant, nous pouvons encore rencontrer des différences clés dans cette classe particulière
Avec le développement de la technologie, l'industrie médicale progresse également constamment et les humains accordent souvent plus d'attention à leur propre santé.
En apprenant et en traitant des ensembles de données par ordinateur, les maladies peuvent être prédites.
Prérequis: Capacité à utiliser FHIR et ML
Nous avons un délicieux dataset avec des recettes écrites par plusieurs utilisateurs de Reddit, mais la plupart des informations sont du texte libre comme le titre ou la description d'un article. Voyons comment nous pouvons très facilement charger l'ensemble de données, extraire certaines fonctionnalités et l'analyser à l'aide des fonctionnalités du grand modèle de langage OpenAI contenu dans Embedded Python et le framework Langchain.
Tout d’abord, nous devons charger l’ensemble de données ou pouvons-nous simplement nous y connecter ?
Il existe différentes manières d'y parvenir : par exemple CSV Record Mapper vous pouvez utiliser dans une production d'interopérabilité ou même de belles applications OpenExchange comme csvgen.
Nous utiliserons Foreign Tables. Une fonctionnalité très utile pour projeter des données physiquement stockées ailleurs vers IRIS SQL. Nous pouvons l'utiliser pour avoir une toute première vue des fichiers de l'ensemble de données.
Nous créons un Foreign Server:
CREATE FOREIGN SERVER dataset FOREIGN DATA WRAPPER CSV HOST '/app/data/'
Et puis une table étrangère qui se connecte au fichier CSV:
CREATE FOREIGN TABLE dataset.Recipes (
CREATEDDATE DATE,
NUMCOMMENTS INTEGER,
TITLE VARCHAR,
USERNAME VARCHAR,
COMMENT VARCHAR,
NUMCHAR INTEGER
) SERVER dataset FILE 'Recipes.csv' USING
{
"from": {
"file": {
"skip": 1
}
}
}
Et voilà, nous pouvons immédiatement exécuter des requêtes SQL sur dataset.Recipes:
## De quelles données avons-nous besoin ? L’ensemble de données est intéressant et nous avons faim. Cependant, si nous voulons décider d'une recette à cuisiner, nous aurons besoin de plus d'informations que nous pourrons utiliser pour analyser.
Nous allons travailler avec deux classes persistantes (tables):
Nous pouvons maintenant charger nos tables yummy.data* avec le contenu de l'ensemble de données:
do ##class(yummy.Utils).LoadDataset()
Cela a l'air bien, mais nous devons encore découvrir comment générer des données pour les champs Score, Difficulty, Ingredients, PreparationTime et CuisineType. ## Analyser les recettes Nous souhaitons traiter le titre et la description de chaque recette et :
Nous allons utiliser ce qui suit :
LLM (large language models) sont vraiment un excellent outil pour traiter le langage naturel.
LangChainest prêt à fonctionner en Python, nous pouvons donc l'utiliser directement dans InterSystems IRIS en utilisant Embedded Python.
La classe complète SimpleOpenAI ressemble à ceci:
/// Analyse OpenAI simple pour les recettes
Class yummy.analysis.SimpleOpenAI Extends Analysis
{
Property CuisineType As %String;
Property PreparationTime As %Integer;
Property Difficulty As %String;
Property Ingredients As %String;
/// Run
/// Vous pouvez essayer ceci depuis un terminal :
/// set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8))
/// do a.Run()
/// zwrite a
Method Run()
{
try {
do ..RunPythonAnalysis()
set reasons = ""
// mes types de cuisine préférés
if "spanish,french,portuguese,italian,korean,japanese"[..CuisineType {
set ..Score = ..Score + 2
set reasons = reasons_$lb("It seems to be a "_..CuisineType_" recipe!")
}
// je ne veux pas passer toute la journée à cuisiner :)
if (+..PreparationTime < 120) {
set ..Score = ..Score + 1
set reasons = reasons_$lb("You don't need too much time to prepare it")
}
// bonus pour les ingrédients préférés !
set favIngredients = $listbuild("kimchi", "truffle", "squid")
for i=1:1:$listlength(favIngredients) {
set favIngred = $listget(favIngredients, i)
if ..Ingredients[favIngred {
set ..Score = ..Score + 1
set reasons = reasons_$lb("Favourite ingredient found: "_favIngred)
}
}
set ..Reason = $listtostring(reasons, ". ")
} catch ex {
throw ex
}
}
/// Mettre à jour la recette avec les résultats de l'analyse
Method UpdateRecipe()
{
try {
// appeler d'abord l'implémentation de la classe parent
do ##super()
// ajouter des résultats d'analyse spécifiques à OpenAI
set ..Recipe.Ingredients = ..Ingredients
set ..Recipe.PreparationTime = ..PreparationTime
set ..Recipe.Difficulty = ..Difficulty
set ..Recipe.CuisineType = ..CuisineType
} catch ex {
throw ex
}
}
/// Exécuter une analyse à l'aide de Embedded Python + Langchain
/// do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(8)).RunPythonAnalysis(1)
Method RunPythonAnalysis(debug As %Boolean = 0) [ Language = python ]
{
# load OpenAI APIKEY from env
import os
from dotenv import load_dotenv, find_dotenv
_ = load_dotenv('/app/.env')
# account for deprecation of LLM model
import datetime
current_date = datetime.datetime.now().date()
# date after which the model should be set to "gpt-3.5-turbo"
target_date = datetime.date(2024, 6, 12)
# set the model depending on the current date
if current_date > target_date:
llm_model = "gpt-3.5-turbo"
else:
llm_model = "gpt-3.5-turbo-0301"
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.chains import LLMChain
from langchain.output_parsers import ResponseSchema
from langchain.output_parsers import StructuredOutputParser
# init llm model
llm = ChatOpenAI(temperature=0.0, model=llm_model)
# prepare the responses we need
cuisine_type_schema = ResponseSchema(
name="cuisine_type",
description="What is the cuisine type for the recipe? \
Answer in 1 word max in lowercase"
)
preparation_time_schema = ResponseSchema(
name="preparation_time",
description="How much time in minutes do I need to prepare the recipe?\
Anwer with an integer number, or null if unknown",
type="integer",
)
difficulty_schema = ResponseSchema(
name="difficulty",
description="How difficult is this recipe?\
Answer with one of these values: easy, normal, hard, very-hard"
)
ingredients_schema = ResponseSchema(
name="ingredients",
description="Give me a comma separated list of ingredients in lowercase or empty if unknown"
)
response_schemas = [cuisine_type_schema, preparation_time_schema, difficulty_schema, ingredients_schema]
# get format instructions from responses
output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()
analysis_template = """\
Interprete and evaluate a recipe which title is: {title}
and the description is: {description}
{format_instructions}
"""
prompt = ChatPromptTemplate.from_template(template=analysis_template)
messages = prompt.format_messages(title=self.Recipe.Title, description=self.Recipe.Description, format_instructions=format_instructions)
response = llm(messages)
if debug:
print("======ACTUAL PROMPT")
print(messages[0].content)
print("======RESPONSE")
print(response.content)
# populate analysis with results
output_dict = output_parser.parse(response.content)
self.CuisineType = output_dict['cuisine_type']
self.Difficulty = output_dict['difficulty']
self.Ingredients = output_dict['ingredients']
if type(output_dict['preparation_time']) == int:
self.PreparationTime = output_dict['preparation_time']
return 1
}
}
La méthode RunPythonAnalysis c'est ici qu'entre en jeu OpenAI :). Vous pouvez le lancer directement depuis votre terminal pour une recette donnée :
do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)
Nous obtiendrons un résultat comme celui-ci :
USER>do ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12)).RunPythonAnalysis(1)
======ACTUAL PROMPT
Interprete and evaluate a recipe which title is: Folded Sushi - Alaska Roll
and the description is: Craving for some sushi but don't have a sushi roller? Try this easy version instead. It's super easy yet equally delicious!
[Video Recipe](https://www.youtube.com/watch?v=1LJPS1lOHSM)
# Ingredients
Serving Size: \~5 sandwiches
* 1 cup of sushi rice
* 3/4 cups + 2 1/2 tbsp of water
* A small piece of konbu (kelp)
* 2 tbsp of rice vinegar
* 1 tbsp of sugar
* 1 tsp of salt
* 2 avocado
* 6 imitation crab sticks
* 2 tbsp of Japanese mayo
* 1/2 lb of salmon
# Recette
* Place 1 cup of sushi rice into a mixing bowl and wash the rice at least 2 times or until the water becomes clear. Then transfer the rice into the rice cooker and add a small piece of kelp along with 3/4 cups plus 2 1/2 tbsp of water. Cook according to your rice cookers instruction.
* Combine 2 tbsp rice vinegar, 1 tbsp sugar, and 1 tsp salt in a medium bowl. Mix until everything is well combined.
* After the rice is cooked, remove the kelp and immediately scoop all the rice into the medium bowl with the vinegar and mix it well using the rice spatula. Make sure to use the cut motion to mix the rice to avoid mashing them. After thats done, cover it with a kitchen towel and let it cool down to room temperature.
* Cut the top of 1 avocado, then slice into the center of the avocado and rotate it along your knife. Then take each half of the avocado and twist. Afterward, take the side with the pit and carefully chop into the pit and twist to remove it. Then, using your hand, remove the peel. Repeat these steps with the other avocado. Dont forget to clean up your work station to give yourself more space. Then, place each half of the avocado facing down and thinly slice them. Once theyre sliced, slowly spread them out. Once thats done, set it aside.
* Remove the wrapper from each crab stick. Then, using your hand, peel the crab sticks vertically to get strings of crab sticks. Once all the crab sticks are peeled, rotate them sideways and chop them into small pieces, then place them in a bowl along with 2 tbsp of Japanese mayo and mix until everything is well mixed.
* Place a sharp knife at an angle and thinly slice against the grain. The thickness of the cut depends on your preference. Just make sure that all the pieces are similar in thickness.
* Grab a piece of seaweed wrap. Using a kitchen scissor, start cutting at the halfway point of seaweed wrap and cut until youre a little bit past the center of the piece. Rotate the piece vertically and start building. Dip your hand in some water to help with the sushi rice. Take a handful of sushi rice and spread it around the upper left hand quadrant of the seaweed wrap. Then carefully place a couple slices of salmon on the top right quadrant. Then place a couple slices of avocado on the bottom right quadrant. And finish it off with a couple of tsp of crab salad on the bottom left quadrant. Then, fold the top right quadrant into the bottom right quadrant, then continue by folding it into the bottom left quadrant. Well finish off the folding by folding the top left quadrant onto the rest of the sandwich. Afterward, place a piece of plastic wrap on top, cut it half, add a couple pieces of ginger and wasabi, and there you have it.
Le résultat doit être un extrait de code de démarque formaté selon le schéma suivant, incluant les caractères "```json" and "```" :
json
{
"cuisine_type": string // Quel est le type de cuisine de la recette ? Réponse en 1 mot maximum en minuscule
"preparation_time": integer // De combien de temps en minutes ai-je besoin pour préparer la recette ? Répondez avec un nombre entier, ou nul si inconnu
"difficulty": string // À quel point cette recette est-elle difficile ? Répondez avec l'une de ces valeurs : facile, normal, difficile, très difficile
"ingredients": string // Donnez-moi une liste d'ingrédients séparés par des virgules en minuscules ou vide si inconnu
}
======RESPONSE
json
{
"cuisine_type": "japanese",
"preparation_time": 30,
"difficulty": "easy",
"ingredients": "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
}
Ça à l'air bon. Il semble que notre invite OpenAI soit capable de renvoyer des informations utiles. Exécutons toute la classe d'analyse depuis le terminal :
set a = ##class(yummy.analysis.SimpleOpenAI).%New(##class(yummy.data.Recipe).%OpenId(12))
do a.Run()
zwrite a
USER>zwrite a
a=37@yummy.analysis.SimpleOpenAI ; <OREF>
+----------------- general information ---------------
| oref value: 37
| class name: yummy.analysis.SimpleOpenAI
| reference count: 2
+----------------- attribute values ------------------
| CuisineType = "japanese"
| Difficulty = "easy"
| Ingredients = "sushi rice, water, konbu, rice vinegar, sugar, salt, avocado, imitation crab sticks, japanese mayo, salmon"
| PreparationTime = 30
| Reason = "It seems to be a japanese recipe!. You don't need too much time to prepare it"
| Score = 3
+----------------- swizzled references ---------------
| i%Recipe = ""
| r%Recipe = "30@yummy.data.Recipe"
+-----------------------------------------------------
## Analyser toutes les recettes ! Naturellement, vous souhaitez exécuter l’analyse sur toutes les recettes que nous avons chargées.
Vous pouvez analyser une gamme d’identifiants de recettes de cette façon :
USER>do ##class(yummy.Utils).AnalyzeRange(1,10)
> Recipe 1 (1.755185s)
> Recipe 2 (2.559526s)
> Recipe 3 (1.556895s)
> Recipe 4 (1.720246s)
> Recipe 5 (1.689123s)
> Recipe 6 (2.404745s)
> Recipe 7 (1.538208s)
> Recipe 8 (1.33001s)
> Recipe 9 (1.49972s)
> Recipe 10 (1.425612s)
Après cela, regardez à nouveau votre tableau de recettes et vérifiez les résultats.
select * from yummy_data.Recipe
Je pense que je pourrais essayer la pizza à la courge poivrée ou le kimchi coréen au tofu et au porc :). De toute façon, je devrai vérifier à la maison :)
Vous pouvez trouver l'exemple complet sur https://github.com/isc-afuentes/recipe-inspector
Avec cet exemple simple, nous avons appris à utiliser les techniques LLM pour ajouter des fonctionnalités ou analyser certaines parties de vos données dans InterSystems IRIS.
Avec ce point de départ, vous pourriez penser à :
Quelles autres choses pourriez-vous essayer ? Laissez-moi savoir ce que vous pensez!
InterSystems prend en charge l'utilisation des images InterSystems IRIS Docker qu'il fournit sous Linux uniquement. Plutôt que d'exécuter des conteneurs en tant que processus natifs, comme sur les plateformes Linux, Docker pour Windows crée une VM Linux fonctionnant sous Hyper-V, le virtualiseur Windows, pour héberger les conteneurs. Ces couches supplémentaires ajoutent une complexité qui empêche InterSystems de prendre en charge Docker pour Windows pour le moment.
🔥 Curieux de connaître le standard FHIR dont tout le monde parle ?
📚 Poursuivez votre lecture pour une brève introduction, puis essayez un tout nouveau parcours d'apprentissage pour approfondir vos connaissances !
Le standard HL7® FHIR® a révolutionné la façon dont les développeurs de soins de santé relèvent les défis de l'interopérabilité des données. FHIR permet aux systèmes de santé d'échanger des informations de manière transparente et les données des patients peuvent être consolidées en temps réel, quel que soit l'endroit où elles sont stockées.
Pour votre commodité, InterSystems publie les étapes d'installation typiques pour les systèmes d'exploitation pris en charge par InterSystems IRIS.
Pour Microsoft Windows, veuillez consulter la documentation.
Le programme d'installation d'IRIS détectera si un serveur Web est installé sur la même machine, ce qui vous donne la possibilité de configurer automatiquement le serveur Web.
Toutes les installations Apache nécessiteront une autorisation sudo (recommandé) ou root pour installer le serveur Web. Cette exigence prend en charge les meilleures pratiques recommandées.
Bonjour La Communauté,
en utilisant un Business Service de type SQL, il peut arriver que nous ayons besoin de rejouer certaines lignes de la table source.
Prenons comme exemple le Business Service "from customer SQL" utilisant la classe générique EnsLib.SQL.Service.GenericService
Différents cas se présentent, en fonction des paramétres utilisés sur ce Business Service.
Premier cas :
Si le Business Service utilise uniquement un champ clé (KeyFieldName)
Bonjour les développeurs,
Commencez à regarder notre dernière vidéo sur InterSystems Developers YouTube:
⏯ North West London Integrated Care System Go Live with Health Connect Cloud @ Global Summit 2023
Bonjour La Communauté!!
Nous vous apportons les dernières nouvelles de InterSystems Ideas, le portail de suggestions InterSystems. Il s'agit de :
✓ Nouvelle page dans le portail des idées -> Gagnants de l'Ideathon (InterSystems Ideas Marathon)
✓ Idées mises en œuvre qui seront expliquées dans les annonces futures
✓ Nouvelles idées publiées récemment
À l'ère numérique d'aujourd'hui, une gestion efficace des données et une analyse précise des informations deviennent essentielles au succès des opérations de l'entreprise. InterSystems IRIS Data Platform propose deux outils essentiels, ARCHITECTE et ANALYSEUR, développés pour offrir une gestion pratique des données.
À l'ère numérique d'aujourd'hui, une gestion efficace des données et une analyse précise des informations deviennent essentielles au succès des opérations de l'entreprise. InterSystems IRIS Data Platform propose deux outils essentiels conçus pour assurer une gestion pratique des données : ARCHITECTE et ANALYSEUR.
Bonjour à toutes et à tous,
Ceci est un exemple complet d'utilisation d'un %ScrollableResultSet pour la pagination des résultats à l'aide de %DynamicQuery:SQL et créer une réponse JSON incluant les détails de la page.
N'hésitez pas à l'utiliser, le partager, le commenter ou l'améliorer.
Cordialement
Nous sommes ravis d'annoncer une nouvelle partie de la documentation InterSystems qui facilite la mise à niveau de la plateforme de données InterSystems IRIS®, InterSystems IRIS® for Health™ ou HealthShare® Health Connect. La liste de contrôle de l'impact de la mise à niveau sur https://docs.intersystems.com/upgrade vous montre tous les éléments que vous devez prendre en compte – et uniquement les éléments que vous devez prendre en compte – lors d'une mise à niveau entre deux versions. Cela reprend tout le contenu de notre « Historique d'incompatibilité » et ajoute des filtres pratiques, des
Lorsqu'AMD a publié la norme x86-64 en 1999, ils ne savaient pas qu'ils inventaient ce qui allait devenir de facto l'architecture des processeurs de serveur. Mais les processeurs d'aujourd'hui ne sont pas les mêmes que ceux produits il y a 20 ans : ils disposent d'extensions pour tout, depuis les Advanced Vector Extensions (AVX) jusqu'à la Hardware-Assisted Virtualization (VT-d).
InterSystems souhaite mieux profiter de ces nouvelles extensions dans les prochaines versions d'InterSystems IRIS. Bien que nos compilateurs soient suffisamment intelligents pour créer du code optimisé pour de nombreuses situations, certaines optimisations ne peuvent être activées qu'en supprimant explicitement la prise en charge des processeurs qui ne disposent pas de ce jeu d'instructions. De plus, nous avons de plus en plus de mal à conserver les anciens modèles de processeurs sur lesquels effectuer des tests.
Comme annoncé pour la première fois en mai, et après de nombreuses présentations et discussions approfondies lors du Global Summit 2023, nous poursuivons notre projet de rendre obsolète InterSystems Studio (obsolète désigne une fonctionnalité ou une technologie qu'InterSystems ne développe plus activement et pour laquelle de meilleures options existent).
Salut les Développeurs,
regardez la nouvelle vidéo sur InterSystems Developers YouTube:
⏯ Columnar Storage - The Lean Data Warehouse @ Global Summit 2023
Nous sommes ravis d'annoncer le dernier ajout à notre programme d'accès anticipé (EAP - Early Access Program) : l'outil - the Health Data De-ID.
L'outil désidentifiera les données cliniques structurées conformément au HIPAA Safe Harbor et permettra une réidentification si nécessaire. Il utilise le format canonique SDA d'InterSystems qui est utilisé pour toutes nos transformations standards d'un format à un autre, telles que HL7 en CDA, HL7 en FHIR, etc. Cet outil utilise des transformations XSLT pour de meilleures performances. De fait, il fournit des méthodes d'assistance qui permettent un ajustement plus facile des règles de désidentification prêtes à l'emploi pour lesquelles vous n'avez pas besoin d'être un expert XSLT.
Health Data De-ID fonctionne sur n'importe quel produit InterSystems, d'InterSystems IRIS for Health à Health Connect en passant par Unified Care Record.
Vous pouvez rejoindre le programme d'accès anticipé ici - Inscription au programme d'accès anticipé au désidentification des données de santé. Nous avons besoin de vos commentaires, alors n'hésitez pas à nous contacter tout au long du processus ou si vous avez des questions.